enabled parallel tests.

starting up only one container for shared containers and setup in some parent class.

Author: marciovmartins

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

@@ -1,5 +1,7 @@
 package org.testcontainers.junit.jupiter;
 
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
 import lombok.Getter;
 import org.junit.jupiter.api.extension.AfterAllCallback;
 import org.junit.jupiter.api.extension.AfterEachCallback;
@@ -23,7 +25,6 @@
 import org.testcontainers.lifecycle.TestLifecycleAware;
 
 import java.lang.reflect.Field;
-import java.lang.reflect.Method;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Optional;
@@ -41,6 +42,7 @@ class TestcontainersExtension implements BeforeEachCallback, BeforeAllCallback,
     private static final String TEST_INSTANCE = "testInstance";
     private static final String SHARED_LIFECYCLE_AWARE_CONTAINERS = "sharedLifecycleAwareContainers";
     private static final String LOCAL_LIFECYCLE_AWARE_CONTAINERS = "localLifecycleAwareContainers";
+    private static final ConcurrentHashMap<String, StoreAdapterThread> STORE_ADAPTER_THREADS = new ConcurrentHashMap<>();
 
     @Override
     public void postProcessTestInstance(final Object testInstance, final ExtensionContext context) {
@@ -56,7 +58,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()));
+        sharedContainersStoreAdapters.forEach(adapter -> store.getOrComputeIfAbsent(adapter.getKey(), k -> storeAdapterStart(k, adapter)));
 
         List<TestLifecycleAware> lifecycleAwareContainers = sharedContainersStoreAdapters
             .stream()
@@ -93,6 +95,20 @@ public void afterEach(ExtensionContext context) {
         signalAfterTestToContainersFor(LOCAL_LIFECYCLE_AWARE_CONTAINERS, context);
     }
 
+    private static synchronized StoreAdapter storeAdapterStart(String key, StoreAdapter adapter) {
+        boolean isInitialized = STORE_ADAPTER_THREADS.containsKey(key);
+
+        if (!isInitialized) {
+            StoreAdapter storeAdapter = adapter.start();
+            STORE_ADAPTER_THREADS.put(key, new StoreAdapterThread(storeAdapter));
+            return storeAdapter;
+        }
+
+        StoreAdapterThread storeAdapter = STORE_ADAPTER_THREADS.get(key);
+        storeAdapter.threads.incrementAndGet();
+        return storeAdapter.storeAdapter;
+    }
+
     private void signalBeforeTestToContainers(List<TestLifecycleAware> lifecycleAwareContainers, TestDescription testDescription) {
         lifecycleAwareContainers.forEach(container -> container.beforeTest(testDescription));
     }
@@ -229,9 +245,9 @@ private static StoreAdapter getContainerInstance(final Object testInstance, fina
     private static class StoreAdapter implements CloseableResource {
 
         @Getter
-        private String key;
+        private final String key;
 
-        private Startable container;
+        private final Startable container;
 
         private StoreAdapter(Class<?> declaringClass, String fieldName, Startable container) {
             this.key = declaringClass.getName() + "." + fieldName;
@@ -245,7 +261,25 @@ private StoreAdapter start() {
 
         @Override
         public void close() {
-            container.stop();
+            int total = STORE_ADAPTER_THREADS.getOrDefault(key, StoreAdapterThread.NULL).threads.decrementAndGet();
+            if (total < 1) {
+                container.stop();
+                STORE_ADAPTER_THREADS.remove(key);
+            }
+        }
+
+    }
+
+    private static class StoreAdapterThread {
+
+        public static final StoreAdapterThread NULL = new StoreAdapterThread(null);
+        public final StoreAdapter storeAdapter;
+        public final AtomicInteger threads = new AtomicInteger(1);
+
+        private StoreAdapterThread(StoreAdapter storeAdapter) {
+            this.storeAdapter = storeAdapter;
         }
+
     }
+
 }

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

@@ -0,0 +1,88 @@
+package org.testcontainers.junit.jupiter;
+
+import static org.junit.Assert.assertEquals;
+import static org.testcontainers.junit.jupiter.JUnitJupiterTestImages.POSTGRES_IMAGE;
+
+import com.zaxxer.hikari.HikariConfig;
+import com.zaxxer.hikari.HikariDataSource;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.parallel.Execution;
+import org.junit.jupiter.api.parallel.ExecutionMode;
+import org.testcontainers.containers.PostgreSQLContainer;
+
+@Testcontainers
+@Execution(ExecutionMode.CONCURRENT)
+public class ParallelContainerTests {
+
+    @Container
+    protected static final PostgreSQLContainer<?> POSTGRE_SQL_CONTAINER = new PostgreSQLContainer<>(POSTGRES_IMAGE)
+        .withDatabaseName("foo")
+        .withUsername("foo")
+        .withPassword("secret");
+
+    @Test
+    void container_should_be_running_first_test() throws SQLException {
+        assertContainerIsRunning(POSTGRE_SQL_CONTAINER);
+    }
+
+    @Test
+    void container_should_be_running_second_test() throws SQLException {
+        assertContainerIsRunning(POSTGRE_SQL_CONTAINER);
+    }
+
+    @Nested
+    @Execution(ExecutionMode.CONCURRENT)
+    class FirstParallelTest extends BaseContainerTests {
+
+        @Test
+        void container_should_be_running() throws SQLException {
+            assertContainerIsRunning(POSTGRE_SQL_BASE_CONTAINER);
+        }
+
+    }
+
+    @Nested
+    @Execution(ExecutionMode.CONCURRENT)
+    class SecondParallelTest extends BaseContainerTests {
+
+        @Test
+        void container_should_be_running() throws SQLException {
+            assertContainerIsRunning(POSTGRE_SQL_BASE_CONTAINER);
+        }
+
+    }
+
+    @Testcontainers
+    private static class BaseContainerTests {
+
+        @Container
+        protected static final PostgreSQLContainer<?> POSTGRE_SQL_BASE_CONTAINER = new PostgreSQLContainer<>(POSTGRES_IMAGE)
+            .withDatabaseName("foo")
+            .withUsername("foo")
+            .withPassword("secret");
+
+    }
+
+    @SuppressWarnings({"SqlDialectInspection", "SqlNoDataSourceInspection"})
+    private static void assertContainerIsRunning(PostgreSQLContainer<?> container) throws SQLException {
+        HikariConfig hikariConfig = new HikariConfig();
+        hikariConfig.setJdbcUrl(container.getJdbcUrl());
+        hikariConfig.setUsername("foo");
+        hikariConfig.setPassword("secret");
+
+        try (HikariDataSource ds = new HikariDataSource(hikariConfig)) {
+            Statement statement = ds.getConnection().createStatement();
+            statement.execute("SELECT 1");
+            ResultSet resultSet = statement.getResultSet();
+            resultSet.next();
+
+            int resultSetInt = resultSet.getInt(1);
+            assertEquals(1, resultSetInt);
+        }
+    }
+
+}

modules/junit-jupiter/src/test/resources/junit-platform.properties

@@ -0,0 +1,3 @@
+junit.jupiter.execution.parallel.enabled=true
+junit.jupiter.execution.parallel.mode.default=same_thread
+junit.jupiter.execution.parallel.mode.classes.default=same_thread