make exposing host ports work when used together with a reusable container

Author: TomDeBacker

core/src/main/java/org/testcontainers/containers/GenericContainer.java

@@ -446,7 +446,9 @@ private void tryStart() {
                 copyToTransferableContainerPathMap.forEach(this::copyFileToContainer);
             }
 
-            connectToPortForwardingNetwork(createCommand.getNetworkMode());
+            if (!reused) {
+                connectToPortForwardingNetwork(createCommand.getNetworkMode());
+            }
 
             if (!reused) {
                 containerIsCreated(containerId);

core/src/test/java/org/testcontainers/containers/ExposedHostTest.java

@@ -7,17 +7,23 @@
 import org.junit.AfterClass;
 import org.junit.BeforeClass;
 import org.junit.Test;
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+import org.testcontainers.DockerClientFactory;
 import org.testcontainers.TestImages;
 import org.testcontainers.Testcontainers;
 
+import java.io.IOException;
 import java.io.OutputStream;
 import java.net.InetSocketAddress;
+import java.util.UUID;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
 public class ExposedHostTest {
 
     private static HttpServer server;
+    private static Network network;
 
     @BeforeClass
     public static void setUpClass() throws Exception {
@@ -33,13 +39,14 @@ public static void setUpClass() throws Exception {
                 }
             }
         );
-
         server.start();
+        network = createReusableNetwork(UUID.randomUUID());
     }
 
     @AfterClass
     public static void tearDownClass() {
         server.stop(0);
+        DockerClientFactory.instance().client().removeNetworkCmd(network.getId()).exec();
     }
 
     @After
@@ -82,6 +89,65 @@ public void testExposedHostPortOnFixedInternalPorts() {
         assertResponse(new GenericContainer<>(tinyContainerDef()), 81);
     }
 
+    @Test
+    public void testExposedHostWithReusableContainerAndFixedNetworkName() throws IOException, InterruptedException {
+        Testcontainers.exposeHostPorts(server.getAddress().getPort());
+
+        try (
+            GenericContainer<?> container = new GenericContainer<>(tinyContainerDef())
+                .withReuse(true)
+                .withNetwork(network)
+        ) {
+            container.start();
+
+            assertHttpResponseFromHost(container, server.getAddress().getPort());
+
+            PortForwardingContainer.INSTANCE.reset();
+            Testcontainers.exposeHostPorts(server.getAddress().getPort());
+
+            try (
+                GenericContainer<?> reusedContainer = new GenericContainer<>(tinyContainerDef())
+                    .withReuse(true)
+                    .withNetwork(network)
+            ) {
+                reusedContainer.start();
+
+                assertThat(reusedContainer.getContainerId()).isEqualTo(container.getContainerId());
+                assertHttpResponseFromHost(reusedContainer, server.getAddress().getPort());
+            }
+        }
+    }
+
+    @Test
+    public void testExposedHostOnFixedInternalPortsWithReusableContainerAndFixedNetworkName()
+        throws IOException, InterruptedException {
+        Testcontainers.exposeHostPorts(ImmutableMap.of(server.getAddress().getPort(), 1234));
+
+        try (
+            GenericContainer<?> container = new GenericContainer<>(tinyContainerDef())
+                .withReuse(true)
+                .withNetwork(network)
+        ) {
+            container.start();
+
+            assertHttpResponseFromHost(container, 1234);
+
+            PortForwardingContainer.INSTANCE.reset();
+            Testcontainers.exposeHostPorts(ImmutableMap.of(server.getAddress().getPort(), 1234));
+
+            try (
+                GenericContainer<?> reusedContainer = new GenericContainer<>(tinyContainerDef())
+                    .withReuse(true)
+                    .withNetwork(network)
+            ) {
+                reusedContainer.start();
+
+                assertThat(reusedContainer.getContainerId()).isEqualTo(container.getContainerId());
+                assertHttpResponseFromHost(reusedContainer, 1234);
+            }
+        }
+    }
+
     @SneakyThrows
     protected void assertResponse(GenericContainer<?> container, int port) {
         try {
@@ -108,4 +174,55 @@ private static class TinyContainerDef extends ContainerDef {
             setCommand("top");
         }
     }
+
+    private void assertHttpResponseFromHost(GenericContainer<?> container, int port)
+        throws IOException, InterruptedException {
+        String httpResponseFromHost = container
+            .execInContainer("wget", "-O", "-", "http://host.testcontainers.internal:" + port)
+            .getStdout();
+        assertThat(httpResponseFromHost).isEqualTo("Hello World!");
+    }
+
+    private static Network createReusableNetwork(UUID name) {
+        String id = DockerClientFactory
+            .instance()
+            .client()
+            .listNetworksCmd()
+            .exec()
+            .stream()
+            .filter(network ->
+                network.getName().equals(name.toString()) &&
+                network.getLabels().equals(DockerClientFactory.DEFAULT_LABELS)
+            )
+            .map(com.github.dockerjava.api.model.Network::getId)
+            .findFirst()
+            .orElseGet(() ->
+                DockerClientFactory
+                    .instance()
+                    .client()
+                    .createNetworkCmd()
+                    .withName(name.toString())
+                    .withCheckDuplicate(true)
+                    .withLabels(DockerClientFactory.DEFAULT_LABELS)
+                    .exec()
+                    .getId()
+            );
+
+        return new Network() {
+            @Override
+            public Statement apply(Statement base, Description description) {
+                return base;
+            }
+
+            @Override
+            public String getId() {
+                return id;
+            }
+
+            @Override
+            public void close() {
+                // never close
+            }
+        };
+    }
 }