Add support for compose v2 with ComposeContainer

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

@@ -39,6 +39,7 @@
 import org.testcontainers.utility.MountableFile;
 import org.testcontainers.utility.PathUtils;
 import org.testcontainers.utility.ResourceReaper;
+import org.testcontainers.utility.TestcontainersConfiguration;
 import org.zeroturnaround.exec.InvalidExitValueException;
 import org.zeroturnaround.exec.ProcessExecutor;
 import org.zeroturnaround.exec.stream.slf4j.Slf4jStream;
@@ -119,6 +120,8 @@ public class DockerComposeContainer<SELF extends DockerComposeContainer<SELF>>
 
     private RemoveImages removeImages;
 
+    private boolean composeV2 = false;
+
     @Deprecated
     public DockerComposeContainer(File composeFile, String identifier) {
         this(identifier, composeFile);
@@ -137,6 +140,7 @@ public DockerComposeContainer(String identifier, File... composeFiles) {
     }
 
     public DockerComposeContainer(String identifier, List<File> composeFiles) {
+        this.composeV2 = TestcontainersConfiguration.getInstance().isComposeV2Enabled();
         this.composeFiles = composeFiles;
         this.dockerComposeFiles = new DockerComposeFiles(composeFiles);
 
@@ -238,7 +242,7 @@ private void createServices() {
             .distinct()
             .collect(Collectors.joining(" "));
 
-        String command = optionsAsString() + "up -d";
+        String command = optionsAsString() + getUpCommand();
 
         if (build) {
             command += " --build";
@@ -318,7 +322,7 @@ private void waitUntilServiceStarted(String serviceName, ComposeServiceWaitStrat
     private String getServiceNameFromContainer(Container container) {
         final String containerName = container.getLabels().get("com.docker.compose.service");
         final String containerNumber = container.getLabels().get("com.docker.compose.container-number");
-        return String.format("%s_%s", containerName, containerNumber);
+        return String.format("%s%s%s", containerName, composeSeparator(), containerNumber);
     }
 
     private void runWithCompose(String cmd) {
@@ -329,7 +333,10 @@ private void runWithCompose(String cmd) {
         if (localCompose) {
             dockerCompose = new LocalDockerCompose(composeFiles, project);
         } else {
-            dockerCompose = new ContainerisedDockerCompose(composeFiles, project);
+            DockerImageName composeImageName = composeV2
+                ? ContainerisedDockerCompose.DEFAULT_IMAGE_NAME
+                : ContainerisedDockerCompose.DEFAULT_COMPOSE_IMAGE_NAME;
+            dockerCompose = new ContainerisedDockerCompose(composeImageName, composeFiles, project);
         }
 
         dockerCompose.withCommand(cmd).withEnv(env).invoke();
@@ -366,7 +373,7 @@ public void stop() {
                 ambassadorContainer.stop();
 
                 // Kill the services using docker-compose
-                String cmd = "down -v";
+                String cmd = getDownCommand();
                 if (removeImages != null) {
                     cmd += " --rmi " + removeImages.dockerRemoveImagesType();
                 }
@@ -382,7 +389,7 @@ public SELF withExposedService(String serviceName, int servicePort) {
     }
 
     public DockerComposeContainer withExposedService(String serviceName, int instance, int servicePort) {
-        return withExposedService(serviceName + "_" + instance, servicePort);
+        return withExposedService(serviceName + composeSeparator() + instance, servicePort);
     }
 
     public DockerComposeContainer withExposedService(
@@ -391,7 +398,7 @@ public DockerComposeContainer withExposedService(
         int servicePort,
         WaitStrategy waitStrategy
     ) {
-        return withExposedService(serviceName + "_" + instance, servicePort, waitStrategy);
+        return withExposedService(serviceName + composeSeparator() + instance, servicePort, waitStrategy);
     }
 
     public SELF withExposedService(String serviceName, int servicePort, @NonNull WaitStrategy waitStrategy) {
@@ -417,15 +424,19 @@ public SELF withExposedService(String serviceName, int servicePort, @NonNull Wai
             .computeIfAbsent(serviceInstanceName, __ -> new ConcurrentHashMap<>())
             .put(servicePort, ambassadorPort);
         ambassadorContainer.withTarget(ambassadorPort, serviceInstanceName, servicePort);
-        ambassadorContainer.addLink(new FutureContainer(this.project + "_" + serviceInstanceName), serviceInstanceName);
+        ambassadorContainer.addLink(
+            new FutureContainer(this.project + composeSeparator() + serviceInstanceName),
+            serviceInstanceName
+        );
         addWaitStrategy(serviceInstanceName, waitStrategy);
         return self();
     }
 
     private String getServiceInstanceName(String serviceName) {
         String serviceInstanceName = serviceName;
-        if (!serviceInstanceName.matches(".*_[0-9]+")) {
-            serviceInstanceName += "_1"; // implicit first instance of this service
+        String regex = String.format(".*%s[0-9]+", composeSeparator());
+        if (!serviceInstanceName.matches(regex)) {
+            serviceInstanceName += String.format("%s1", composeSeparator()); // implicit first instance of this service
         }
         return serviceInstanceName;
     }
@@ -504,6 +515,18 @@ public Integer getServicePort(String serviceName, Integer servicePort) {
         }
     }
 
+    private String getUpCommand() {
+        return composeV2 ? "compose up -d" : "up -d";
+    }
+
+    private String getDownCommand() {
+        return composeV2 ? "compose down -v" : "down -v";
+    }
+
+    private String composeSeparator() {
+        return composeV2 ? "-" : "_";
+    }
+
     public SELF withScaledService(String serviceBaseName, int numInstances) {
         scalingPreferences.put(serviceBaseName, numInstances);
 
@@ -653,12 +676,14 @@ interface DockerCompose {
  */
 class ContainerisedDockerCompose extends GenericContainer<ContainerisedDockerCompose> implements DockerCompose {
 
-    public static final char UNIX_PATH_SEPERATOR = ':';
+    public static final char UNIX_PATH_SEPARATOR = ':';
+
+    public static final DockerImageName DEFAULT_COMPOSE_IMAGE_NAME = DockerImageName.parse("docker/compose:1.29.2");
 
-    public static final DockerImageName DEFAULT_IMAGE_NAME = DockerImageName.parse("docker/compose:1.29.2");
+    public static final DockerImageName DEFAULT_IMAGE_NAME = DockerImageName.parse("docker:20.10.17");
 
-    public ContainerisedDockerCompose(List<File> composeFiles, String identifier) {
-        super(DEFAULT_IMAGE_NAME);
+    public ContainerisedDockerCompose(DockerImageName dockerImageName, List<File> composeFiles, String identifier) {
+        super(dockerImageName);
         addEnv(ENV_PROJECT_NAME, identifier);
 
         // Map the docker compose file into the container
@@ -673,7 +698,7 @@ public ContainerisedDockerCompose(List<File> composeFiles, String identifier) {
             .map(MountableFile::getFilesystemPath)
             .map(this::convertToUnixFilesystemPath)
             .collect(Collectors.toList());
-        final String composeFileEnvVariableValue = Joiner.on(UNIX_PATH_SEPERATOR).join(absoluteDockerComposeFiles); // we always need the UNIX path separator
+        final String composeFileEnvVariableValue = Joiner.on(UNIX_PATH_SEPARATOR).join(absoluteDockerComposeFiles); // we always need the UNIX path separator
         logger().debug("Set env COMPOSE_FILE={}", composeFileEnvVariableValue);
         addEnv(ENV_COMPOSE_FILE, composeFileEnvVariableValue);
         addFileSystemBind(pwd, containerPwd, BindMode.READ_WRITE);
@@ -742,6 +767,8 @@ class LocalDockerCompose implements DockerCompose {
         ? "docker-compose.exe"
         : "docker-compose";
 
+    private static final String DOCKER_EXECUTABLE = SystemUtils.IS_OS_WINDOWS ? "docker.exe" : "docker";
+
     private final List<File> composeFiles;
 
     private final String identifier;
@@ -750,6 +777,10 @@ class LocalDockerCompose implements DockerCompose {
 
     private Map<String, String> env = new HashMap<>();
 
+    private static String executable = TestcontainersConfiguration.getInstance().isComposeV2Enabled()
+        ? DOCKER_EXECUTABLE
+        : COMPOSE_EXECUTABLE;
+
     public LocalDockerCompose(List<File> composeFiles, String identifier) {
         this.composeFiles = composeFiles;
         this.identifier = identifier;
@@ -769,16 +800,14 @@ public DockerCompose withEnv(Map<String, String> env) {
 
     @VisibleForTesting
     static boolean executableExists() {
-        return CommandLine.executableExists(COMPOSE_EXECUTABLE);
+        return CommandLine.executableExists(executable);
     }
 
     @Override
     public void invoke() {
         // bail out early
         if (!executableExists()) {
-            throw new ContainerLaunchException(
-                "Local Docker Compose not found. Is " + COMPOSE_EXECUTABLE + " on the PATH?"
-            );
+            throw new ContainerLaunchException("Local Docker Compose not found. Is " + executable + " on the PATH?");
         }
 
         final Map<String, String> environment = Maps.newHashMap(env);
@@ -815,10 +844,7 @@ public void invoke() {
 
         logger().info("Local Docker Compose is running command: {}", cmd);
 
-        final List<String> command = Splitter
-            .onPattern(" ")
-            .omitEmptyStrings()
-            .splitToList(COMPOSE_EXECUTABLE + " " + cmd);
+        final List<String> command = Splitter.onPattern(" ").omitEmptyStrings().splitToList(executable + " " + cmd);
 
         try {
             new ProcessExecutor()
@@ -847,6 +873,6 @@ public void invoke() {
      * @return a logger
      */
     private Logger logger() {
-        return DockerLoggerFactory.getLogger(COMPOSE_EXECUTABLE);
+        return DockerLoggerFactory.getLogger(executable);
     }
 }

core/src/main/java/org/testcontainers/utility/TestcontainersConfiguration.java

@@ -185,6 +185,10 @@ public boolean environmentSupportsReuse() {
         return Boolean.parseBoolean(getEnvVarOrUserProperty("testcontainers.reuse.enable", "false"));
     }
 
+    public boolean isComposeV2Enabled() {
+        return Boolean.parseBoolean(getEnvVarOrUserProperty("composev2.enable", "false"));
+    }
+
     public String getDockerClientStrategyClassName() {
         // getConfigurable won't apply the TESTCONTAINERS_ prefix when looking for env vars if DOCKER_ appears at the beginning.
         // Because of this overlap, and the desire to not change this specific TESTCONTAINERS_DOCKER_CLIENT_STRATEGY setting,

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

@@ -0,0 +1,95 @@
+package org.testcontainers.junit;
+
+import com.github.dockerjava.api.model.Network;
+import org.junit.After;
+import org.junit.Assume;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Rule;
+import org.junit.Test;
+import org.testcontainers.DockerClientFactory;
+import org.testcontainers.containers.DockerComposeContainer;
+import org.testcontainers.utility.TestEnvironment;
+import org.testcontainers.utility.TestcontainersConfiguration;
+import redis.clients.jedis.Jedis;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.hamcrest.Matchers.is;
+import static org.rnorth.visibleassertions.VisibleAssertions.assertEquals;
+import static org.rnorth.visibleassertions.VisibleAssertions.assertThat;
+
+public class DockerComposeV2Test {
+
+    @Rule
+    public DockerComposeContainer environment = new DockerComposeContainer(
+        new File("src/test/resources/v2-compose-test.yml")
+    )
+        .withExposedService("redis-1", REDIS_PORT);
+
+    protected static final int REDIS_PORT = 6379;
+
+    private List<String> existingNetworks = new ArrayList<>();
+
+    @BeforeClass
+    public static void checkVersion() {
+        Assume.assumeTrue(TestEnvironment.dockerApiAtLeast("1.22"));
+        Assume.assumeTrue(TestcontainersConfiguration.getInstance().isComposeV2Enabled());
+    }
+
+    @Test
+    public void simpleTest() {
+        Jedis jedis = new Jedis(
+            this.environment.getServiceHost("redis-1", REDIS_PORT),
+            this.environment.getServicePort("redis-1", REDIS_PORT)
+        );
+
+        jedis.incr("test");
+        jedis.incr("test");
+        jedis.incr("test");
+
+        assertEquals("A redis instance defined in compose can be used in isolation", "3", jedis.get("test"));
+    }
+
+    @Test
+    public void secondTest() {
+        // used in manual checking for cleanup in between tests
+        Jedis jedis = new Jedis(
+            this.environment.getServiceHost("redis-1", REDIS_PORT),
+            this.environment.getServicePort("redis-1", REDIS_PORT)
+        );
+
+        jedis.incr("test");
+        jedis.incr("test");
+        jedis.incr("test");
+
+        assertEquals("Tests use fresh container instances", "3", jedis.get("test"));
+        // if these end up using the same container one of the test methods will fail.
+        // However, @Rule creates a separate DockerComposeContainer instance per test, so this just shouldn't happen
+    }
+
+    @Before
+    public void captureNetworks() {
+        existingNetworks.addAll(findAllNetworks());
+    }
+
+    @After
+    public void verifyNoNetworks() {
+        assertThat("The networks", findAllNetworks(), is(existingNetworks));
+    }
+
+    private List<String> findAllNetworks() {
+        return DockerClientFactory
+            .instance()
+            .client()
+            .listNetworksCmd()
+            .exec()
+            .stream()
+            .map(Network::getName)
+            .sorted()
+            .collect(Collectors.toList());
+    }
+}

core/src/test/java/org/testcontainers/utility/TestcontainersConfigurationTest.java

@@ -253,6 +253,31 @@ public void shouldTrimImageNames() {
         );
     }
 
+    @Test
+    public void shouldNotReadComposeV2FromClasspathProperties() {
+        assertFalse("compose v2 enabled by default", newConfig().isComposeV2Enabled());
+
+        classpathProperties.setProperty("composev2.enable", "true");
+        assertFalse("compose v2 are not affected by classpath properties", newConfig().isComposeV2Enabled());
+    }
+
+    @Test
+    public void shouldReadComposeV2FromUserProperties() {
+        assertFalse("compose v2 enabled by default", newConfig().isComposeV2Enabled());
+
+        userProperties.setProperty("composev2.enable", "true");
+        assertTrue("compose v2 disabled via user properties", newConfig().isComposeV2Enabled());
+    }
+
+    @Test
+    public void shouldReadComposeV2FromEnvironment() {
+        assertFalse("compose v2 enabled by default", newConfig().isComposeV2Enabled());
+
+        userProperties.remove("composev2.enable");
+        environment.put("TESTCONTAINERS_COMPOSEV2_ENABLE", "true");
+        assertTrue("compose v2 disabled via env var", newConfig().isComposeV2Enabled());
+    }
+
     private TestcontainersConfiguration newConfig() {
         return new TestcontainersConfiguration(userProperties, classpathProperties, environment);
     }

docs/features/configuration.md

@@ -129,3 +129,9 @@ In addition, you can deactivate this behaviour by specifying:
 ```properties
 dockerconfig.source=autoIgnoringUserProperties # 'auto' by default
 ```
+
+## Enabling Compose V2 compatibility
+
+> **composev2.enable = [true|false]**
+
+By enabling it, [Compose V2](https://www.docker.com/blog/announcing-compose-v2-general-availability/) will be used. 

docs/modules/docker_compose.md

@@ -119,6 +119,19 @@ public static DockerComposeContainer environment =
             .waitingFor("db_1", Wait.forLogMessage("started", 1))
             .withLocalCompose(true);
 ```
+
+## Compose V2
+
+[Compose V2 is GA](https://www.docker.com/blog/announcing-compose-v2-general-availability/) and it relies in `docker` command instead of `docker-compose`.
+
+```java
+public static DockerComposeContainer environment =
+    new DockerComposeContainer(new File("src/test/resources/compose-test.yml"))
+            .withComposeV2()
+            .withExposedService("redis-1", REDIS_PORT, Wait.forListeningPort())
+            .waitingFor("db-1", Wait.forLogMessage("started", 1));
+```
+
 ## Using private repositories in Docker compose
 When Docker Compose is used in container mode (not local), it's needs to be made aware of Docker settings for private repositories. 
 By default, those setting are located in `$HOME/.docker/config.json`.