public DockerPort availableService(String service, String ip, int externalPortNumber, int internalPortNumber) throws Exception { DockerPort port = port(service, ip, externalPortNumber, internalPortNumber); doReturn(true).when(port).isListeningNow(); return port; }
@Test public void not_have_all_ports_open_if_has_at_least_one_closed_port_and_report_the_name_of_the_port() throws Exception { int unavailablePort = 4321; String unavailablePortString = Integer.toString(unavailablePort); env.availableService("service", IP, 1234, 1234); env.unavailableService("service", IP, unavailablePort, unavailablePort); assertThat(container.areAllPortsOpen(), is(failureWithMessage(containsString(unavailablePortString)))); }
public void ports(String service, String ip, Integer... portNumbers) throws IOException, InterruptedException { List<DockerPort> ports = Arrays.asList(portNumbers) .stream() .map(portNumber -> dockerPortSpy(ip, portNumber, portNumber)) .collect(Collectors.toList()); when(dockerComposeProcess.ports(service)).thenReturn(new Ports(ports)); }
@Test public void call_docker_ports_once_when_two_ports_are_requested() throws Exception { env.ports("service", IP, 8080, 8081); container.port(8080); container.port(8081); verify(dockerCompose, times(1)).ports("service"); }
public DockerPort unavailableHttpService(String service, String ip, int externalPortNumber, int internalPortNumber) throws Exception { DockerPort port = availableService(service, ip, externalPortNumber, internalPortNumber); doReturn(false).when(port).isHttpResponding(any(), eq(false)); return port; }
@Test public void have_all_ports_open_if_all_exposed_ports_are_open() throws Exception { env.availableHttpService("service", IP, 1234, 1234); assertThat(container.areAllPortsOpen(), is(successful())); }
@Test public void not_be_listening_on_http_when_the_port_is_not_and_reports_the_port_number_and_url() throws Exception { int unavailablePort = 1234; String unvaliablePortString = Integer.toString(unavailablePort); env.unavailableHttpService("service", IP, unavailablePort, unavailablePort); assertThat( container.portIsListeningOnHttp(unavailablePort, port -> "http://some.url:" + port.getInternalPort()), is(failureWithMessage(both( containsString(unvaliablePortString)).and( containsString("http://some.url:" + unvaliablePortString) )))); }
@Test public void return_updated_external_port_on_restart() throws IOException, InterruptedException { int internalPort = 5432; env.ephemeralPort("service", IP, internalPort); DockerPort port = container.port(internalPort); int prePort = port.getExternalPort(); DockerPort samePort = container.port(internalPort); assertThat(prePort, is(samePort.getExternalPort())); container.stop(); container.start(); DockerPort updatedPort = container.port(internalPort); assertThat(prePort, not(is(updatedPort.getExternalPort()))); }
@Test public void execute_ps_once_when_two_external_ports_on_a_container_are_requested() throws Exception { env.ports("db", IP, 5432, 8080); withComposeExecutableReturningContainerFor("db"); rule.containers().container("db").port(5432); rule.containers().container("db").port(8080); verify(dockerCompose, times(1)).ports("db"); }
public DockerPort availableHttpService(String service, String ip, int externalPortNumber, int internalPortNumber) throws Exception { DockerPort port = availableService(service, ip, externalPortNumber, internalPortNumber); doReturn(true).when(port).isHttpResponding(any(), eq(false)); doReturn(SuccessOrFailure.success()).when(port).isHttpRespondingSuccessfully(any(), eq(false)); return port; }
@Test public void be_listening_on_http_when_the_port_is() throws Exception { env.availableHttpService("service", IP, 1234, 2345); assertThat( container.portIsListeningOnHttp(2345, port -> "http://some.url:" + port), is(successful())); }
public DockerPort unavailableService(String service, String ip, int externalPortNumber, int internalPortNumber) throws Exception { DockerPort port = port(service, ip, externalPortNumber, internalPortNumber); doReturn(false).when(port).isListeningNow(); return port; }
@Test public void return_port_for_container_when_external_port_number_given() throws Exception { DockerPort expected = env.availableService("service", IP, 5433, 5432); DockerPort port = container.portMappedExternallyTo(5433); assertThat(port, is(expected)); }
public void ephemeralPort(String service, String ip, int internalPortNumber) throws IOException, InterruptedException { AtomicInteger currentExternalPort = new AtomicInteger(33700); when(dockerComposeProcess.ports(service)).then(a -> { DockerPort port = dockerPortSpy(ip, currentExternalPort.incrementAndGet(), internalPortNumber); return new Ports(port); }); }
@Test public void retrieve_port_for_container_by_external_mapping() throws IOException, InterruptedException { DockerPort expectedPort = env.port("db", IP, 5433, 5432); withComposeExecutableReturningContainerFor("db"); DockerPort actualPort = rule.containers().container("db").portMappedExternallyTo(5433); assertThat(actualPort, is(expectedPort)); }
@Test public void return_port_for_container_when_internal_port_number_given() throws Exception { DockerPort expected = env.availableService("service", IP, 5433, 5432); DockerPort port = container.port(5432); assertThat(port, is(expected)); }
public DockerPort port(String service, String ip, int externalPortNumber, int internalPortNumber) throws IOException, InterruptedException { DockerPort port = dockerPortSpy(ip, externalPortNumber, internalPortNumber); when(dockerComposeProcess.ports(service)).thenReturn(new Ports(port)); return port; }
@Test public void retrieve_port_for_container_by_internal_mapping() throws IOException, InterruptedException { DockerPort expectedPort = env.port("db", IP, 5433, 5432); withComposeExecutableReturningContainerFor("db"); @SuppressWarnings("deprecation") // intentionally using the deprecated method temporarily DockerPort actualPort = rule.containers().container("db").portMappedInternallyTo(5432); assertThat(actualPort, is(expectedPort)); }
@Test public void throw_illegal_argument_exception_when_a_port_for_an_unknown_internal_port_is_requested() throws Exception { env.availableService("service", IP, 5400, 5400); exception.expect(IllegalArgumentException.class); exception.expectMessage("No internal port '5432' for container 'service'"); container.port(5432); }
@Test public void throw_illegal_argument_exception_when_a_port_for_an_unknown_external_port_is_requested() throws Exception { // Service must have ports otherwise we end up with an exception telling you the service is listening at all env.availableService("service", IP, 5400, 5400); exception.expect(IllegalArgumentException.class); exception.expectMessage("No port mapped externally to '5432' for container 'service'"); container.portMappedExternallyTo(5432); }