[junit-jupiter] Add parallel attribute to @Testcontainers (#6658)

Fixes #5037

Author: samed-bicer

modules/junit-jupiter/src/main/java/org/testcontainers/junit/jupiter/Testcontainers.java

@@ -63,4 +63,9 @@
      * Whether tests should be disabled (rather than failing) when Docker is not available.
      */
     boolean disabledWithoutDocker() default false;
+
+    /**
+     * Whether containers should start in parallel
+     */
+    boolean parallel() default false;
 }

modules/junit-jupiter/src/main/java/org/testcontainers/junit/jupiter/TestcontainersExtension.java

@@ -18,6 +18,7 @@
 import org.junit.platform.commons.support.ReflectionSupport;
 import org.testcontainers.DockerClientFactory;
 import org.testcontainers.lifecycle.Startable;
+import org.testcontainers.lifecycle.Startables;
 import org.testcontainers.lifecycle.TestDescription;
 import org.testcontainers.lifecycle.TestLifecycleAware;
 
@@ -52,9 +53,7 @@ public void beforeAll(ExtensionContext context) {
         Store store = context.getStore(NAMESPACE);
         List<StoreAdapter> sharedContainersStoreAdapters = findSharedContainers(testClass);
 
-        sharedContainersStoreAdapters.forEach(adapter -> {
-            store.getOrComputeIfAbsent(adapter.getKey(), k -> adapter.start());
-        });
+        startContainers(sharedContainersStoreAdapters, store, context);
 
         List<TestLifecycleAware> lifecycleAwareContainers = sharedContainersStoreAdapters
             .stream()
@@ -66,6 +65,18 @@ public void beforeAll(ExtensionContext context) {
         signalBeforeTestToContainers(lifecycleAwareContainers, testDescriptionFrom(context));
     }
 
+    private void startContainers(List<StoreAdapter> storeAdapters, Store store, ExtensionContext context) {
+        if (storeAdapters.isEmpty()) {
+            return;
+        }
+
+        if (isParallelExecutionEnabled(context)) {
+            Startables.deepStart(storeAdapters.stream().map(storeAdapter -> storeAdapter.container)).join();
+        } else {
+            storeAdapters.forEach(adapter -> store.getOrComputeIfAbsent(adapter.getKey(), k -> adapter.start()));
+        }
+    }
+
     @Override
     public void afterAll(ExtensionContext context) {
         signalAfterTestToContainersFor(SHARED_LIFECYCLE_AWARE_CONTAINERS, context);
@@ -75,18 +86,39 @@ public void afterAll(ExtensionContext context) {
     public void beforeEach(final ExtensionContext context) {
         Store store = context.getStore(NAMESPACE);
 
-        List<TestLifecycleAware> lifecycleAwareContainers = collectParentTestInstances(context)
+        List<StoreAdapter> restartContainers = collectParentTestInstances(context)
             .parallelStream()
             .flatMap(this::findRestartContainers)
-            .peek(adapter -> store.getOrComputeIfAbsent(adapter.getKey(), k -> adapter.start()))
-            .filter(this::isTestLifecycleAware)
-            .map(lifecycleAwareAdapter -> (TestLifecycleAware) lifecycleAwareAdapter.container)
             .collect(Collectors.toList());
 
+        List<TestLifecycleAware> lifecycleAwareContainers = findTestLifecycleAwareContainers(
+            restartContainers,
+            store,
+            context
+        );
+
         store.put(LOCAL_LIFECYCLE_AWARE_CONTAINERS, lifecycleAwareContainers);
         signalBeforeTestToContainers(lifecycleAwareContainers, testDescriptionFrom(context));
     }
 
+    private List<TestLifecycleAware> findTestLifecycleAwareContainers(
+        List<StoreAdapter> restartContainers,
+        Store store,
+        ExtensionContext context
+    ) {
+        startContainers(restartContainers, store, context);
+
+        return restartContainers
+            .stream()
+            .filter(this::isTestLifecycleAware)
+            .map(lifecycleAwareAdapter -> (TestLifecycleAware) lifecycleAwareAdapter.container)
+            .collect(Collectors.toList());
+    }
+
+    private boolean isParallelExecutionEnabled(ExtensionContext context) {
+        return findTestcontainers(context).map(Testcontainers::parallel).orElse(false);
+    }
+
     @Override
     public void afterEach(ExtensionContext context) {
         signalAfterTestToContainersFor(LOCAL_LIFECYCLE_AWARE_CONTAINERS, context);

modules/junit-jupiter/src/test/java/org/testcontainers/junit/jupiter/JUnitJupiterTestImages.java

@@ -5,4 +5,5 @@
 public interface JUnitJupiterTestImages {
     DockerImageName POSTGRES_IMAGE = DockerImageName.parse("postgres:9.6.12");
     DockerImageName HTTPD_IMAGE = DockerImageName.parse("httpd:2.4-alpine");
+    DockerImageName MYSQL_IMAGE = DockerImageName.parse("mysql:8.0.32");
 }

modules/junit-jupiter/src/test/java/org/testcontainers/junit/jupiter/ParallelExecutionTests.java

@@ -0,0 +1,28 @@
+package org.testcontainers.junit.jupiter;
+
+import org.junit.jupiter.api.Test;
+import org.testcontainers.containers.MySQLContainer;
+import org.testcontainers.containers.PostgreSQLContainer;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@Testcontainers(parallel = true)
+public class ParallelExecutionTests {
+
+    @Container
+    private static final PostgreSQLContainer<?> POSTGRESQL_CONTAINER = new PostgreSQLContainer<>(
+        JUnitJupiterTestImages.POSTGRES_IMAGE
+    )
+        .withDatabaseName("foo")
+        .withUsername("foo")
+        .withPassword("secret");
+
+    @Container
+    private MySQLContainer<?> mySQLContainer = new MySQLContainer<>(JUnitJupiterTestImages.MYSQL_IMAGE);
+
+    @Test
+    void test() {
+        assertThat(POSTGRESQL_CONTAINER.isRunning()).isTrue();
+        assertThat(mySQLContainer.isRunning()).isTrue();
+    }
+}