reuse existing tests wherever possible

Author: etrandafir93

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

@@ -37,9 +37,11 @@ public void setUp() {
     @Test
     public void testProfileOption() {
         try (
+            // composeContainerWithLocalCompose {
             ComposeContainer compose = new ComposeContainer(COMPOSE_FILE)
-                .withOptions("--profile=cache")
                 .withLocalCompose(true)
+                // }
+                .withOptions("--profile=cache")
         ) {
             compose.start();
             assertThat(compose.listChildContainers()).hasSize(1);

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

@@ -18,21 +18,30 @@
 public class ComposeContainerTest extends BaseComposeTest {
 
     @Rule
+    // composeContainerConstructor {
     public ComposeContainer environment = new ComposeContainer(
         new File("src/test/resources/composev2/compose-test.yml")
     )
         .withExposedService("redis-1", REDIS_PORT)
         .withExposedService("db-1", 3306);
 
+    // }
+
     @Override
     protected ComposeContainer getEnvironment() {
         return environment;
     }
 
     @Test
-    public void testGetServicePort() {
+    public void testGetServiceHostAndPort() {
+        // getServiceHostAndPort {
+        String serviceHost = environment.getServiceHost("redis-1", REDIS_PORT);
         int serviceWithInstancePort = environment.getServicePort("redis-1", REDIS_PORT);
+        // }
+
+        assertThat(serviceHost).as("Service host is not blank").isNotBlank();
         assertThat(serviceWithInstancePort).as("Port is set for service with instance number").isNotNull();
+
         int serviceWithoutInstancePort = environment.getServicePort("redis", REDIS_PORT);
         assertThat(serviceWithoutInstancePort).as("Port is set for service with instance number").isNotNull();
         assertThat(serviceWithoutInstancePort).as("Service ports are the same").isEqualTo(serviceWithInstancePort);

core/src/test/java/org/testcontainers/junit/ComposeContainerTest.java

@@ -49,11 +49,13 @@ public void testWithFileCopyInclusionUsingFilePath() throws IOException {
     @Test
     public void testWithFileCopyInclusionUsingDirectoryPath() throws IOException {
         try (
+            // composeContainerWithCopyFiles {
             ComposeContainer environment = new ComposeContainer(
                 new File("src/test/resources/compose-file-copy-inclusions/compose-test-only.yml")
             )
                 .withExposedService("app", 8080)
                 .withCopyFilesInContainer("Dockerfile", "EnvVariableRestEndpoint.java", "test")
+            // }
         ) {
             environment.start();
 

core/src/test/java/org/testcontainers/junit/ComposeContainerWithCopyFilesTest.java

@@ -0,0 +1,54 @@
+package org.testcontainers.junit;
+
+import org.junit.Test;
+import org.testcontainers.containers.ComposeContainer;
+import org.testcontainers.containers.wait.strategy.Wait;
+
+import java.io.File;
+import java.time.Duration;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class ComposeContainerWithWaitStrategies {
+
+    private static final int REDIS_PORT = 6379;
+
+    @Test
+    public void testComposeContainerConstructor() {
+        try (
+            // composeContainerWithCombinedWaitStrategies {
+            ComposeContainer compose = new ComposeContainer(new File("src/test/resources/composev2/compose-test.yml"))
+                .withExposedService("redis-1", REDIS_PORT, Wait.forSuccessfulCommand("redis-cli ping"))
+                .withExposedService("db-1", 3306, Wait.forLogMessage(".*ready for connections.*\\n", 1))
+            // }
+        ) {
+            compose.start();
+            containsStartedServices(compose, "redis-1", "db-1");
+        }
+    }
+
+    @Test
+    public void testComposeContainerWaitForPortWithTimeout() {
+        try (
+            // composeContainerWaitForPortWithTimeout {
+            ComposeContainer compose = new ComposeContainer(new File("src/test/resources/composev2/compose-test.yml"))
+                .withExposedService(
+                    "redis-1",
+                    REDIS_PORT,
+                    Wait.forListeningPort().withStartupTimeout(Duration.ofSeconds(30))
+                )
+            // }
+        ) {
+            compose.start();
+            containsStartedServices(compose, "redis-1");
+        }
+    }
+
+    private void containsStartedServices(ComposeContainer compose, String... expectedServices) {
+        for (String serviceName : expectedServices) {
+            assertThat(compose.getContainerByServiceName(serviceName))
+                .as("Container should be found by service name %s", serviceName)
+                .isPresent();
+        }
+    }
+}

core/src/test/java/org/testcontainers/junit/ComposeContainerWithWaitStrategies.java

@@ -13,23 +13,24 @@ The [`ComposeContainer`](http://static.javadoc.io/org.testcontainers/testcontain
 A single class `ComposeContainer`, defined based on a `docker-compose.yml` file, should be sufficient to launch any number of services required by our tests:
 
 <!--codeinclude-->
-[Create a ComposeContainer](../../core/src/test/java/org/testcontainers/containers/ComposeContainerDocTest.java) inside_block:composeContainerConstructor
+[Create a ComposeContainer](../../core/src/test/java/org/testcontainers/junit/ComposeContainerTest.java) inside_block:composeContainerConstructor
 <!--/codeinclude-->
 
 !!! note
     Make sure the service names use a `-` rather than `_` as separator.
 
-In this example, Docker Compose file should have content such as:
+
 ```yaml
-version: '3.8'
+!include ../../core/src/test/resources/composev2/compose-test.yml
+```
 
+In this example, Docker Compose file should have content such as:
+```yaml
 services:
   redis:
-    image: redis:7
-  postgres:
-    image: postgres:17-alpine
-    environment:
-      POSTGRES_USER: postgres
+    image: redis
+  db:
+    image: mysql:8.0.36
 ```
 
 Note that it is not necessary to define ports to be exposed in the YAML file, as this would inhibit the reuse/inclusion of the file in other contexts.
@@ -55,7 +56,7 @@ ComposeContainer provides methods for discovering how your tests can interact wi
 
 Let's use this API to create the URL that will enable our tests to access the Redis service:
 <!--codeinclude-->
-[Access a Service's host and port](../../core/src/test/java/org/testcontainers/containers/ComposeContainerDocTest.java) inside_block:getServiceHostAndPort
+[Access a Service's host and port](../../core/src/test/java/org/testcontainers/junit/ComposeContainerTest.java) inside_block:getServiceHostAndPort
 <!--/codeinclude-->
 
 ## Wait Strategies and Startup Timeouts
@@ -67,15 +68,15 @@ There are overloaded `withExposedService` methods that take a [`WaitStrategy`](h
 
 For instance, we can wait for exposed port and set a custom timeout:
 <!--codeinclude-->
-[Wait for the exposed port and use a custom timeout](../../core/src/test/java/org/testcontainers/containers/ComposeContainerDocTest.java) inside_block:composeContainerWaitForPortWithTimeout
+[Wait for the exposed port and use a custom timeout](../../core/src/test/java/org/testcontainers/junit/ComposeContainerWithWaitStrategies.java) inside_block:composeContainerWaitForPortWithTimeout
 <!--/codeinclude-->
 
 Needless to say, we can define different strategies for each service in our Docker Compose setup. 
 
-For example, our Redis container can wait for a successful redis-cli command, while Postgres waits for a specific log message:
+For example, our Redis container can wait for a successful redis-cli command, while our db service waits for a specific log message:
 
 <!--codeinclude-->
-[Wait for a custom command and a log message](../../core/src/test/java/org/testcontainers/containers/ComposeContainerDocTest.java) inside_block:composeContainerWithCombinedWaitStrategies
+[Wait for a custom command and a log message](../../core/src/test/java/org/testcontainers/junit/ComposeContainerWithWaitStrategies.java) inside_block:composeContainerWithCombinedWaitStrategies
 <!--/codeinclude-->
 
 !!! More on Wait Strategies
@@ -89,15 +90,15 @@ We can override Testcontainers' default behaviour and make it use a `docker-comp
 This will generally yield an experience that is closer to running _docker compose_ locally, with the caveat that Docker Compose needs to be present on dev and CI machines.
 
 <!--codeinclude-->
-[Use ComposeContainer in 'Local Compose' mode](../../core/src/test/java/org/testcontainers/containers/ComposeContainerDocTest.java) inside_block:composeContainerWithLocalCompose
+[Use ComposeContainer in 'Local Compose' mode](../../core/src/test/java/org/testcontainers/containers/ComposeProfilesOptionTest.java) inside_block:composeContainerWithLocalCompose
 <!--/codeinclude-->
 
 ## Build Working Directory
 
 We can select what files should be copied only via `withCopyFilesInContainer`:
 
 <!--codeinclude-->
-[Use ComposeContainer in 'Local Compose' mode](../../core/src/test/java/org/testcontainers/containers/ComposeContainerDocTest.java) inside_block:composeContainerWithCopyFiles
+[Use ComposeContainer in 'Local Compose' mode](../../core/src/test/java/org/testcontainers/junit/ComposeContainerWithCopyFilesTest.java) inside_block:composeContainerWithCopyFiles
 <!--/codeinclude-->
 
 In this example, only docker compose and env files are copied over into the container that will run the Docker Compose file.