Mock TestcontainersConfiguration in ReusabilityUnitTests (#2080)

Author: bsideup

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

@@ -1,5 +1,6 @@
 package org.testcontainers.utility;
 
+import com.google.common.annotations.VisibleForTesting;
 import lombok.*;
 import lombok.extern.slf4j.Slf4j;
 import org.testcontainers.UnstableAPI;
@@ -9,6 +10,7 @@
 import java.net.URL;
 import java.util.Objects;
 import java.util.Properties;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.stream.Stream;
 
 /**
@@ -24,7 +26,14 @@ public class TestcontainersConfiguration {
     private static File ENVIRONMENT_CONFIG_FILE = new File(System.getProperty("user.home"), "." + PROPERTIES_FILE_NAME);
 
     @Getter(lazy = true)
-    private static final TestcontainersConfiguration instance = loadConfiguration();
+    private static final TestcontainersConfiguration instance = loadConfiguration();;
+
+    @SuppressWarnings({"ConstantConditions", "unchecked", "rawtypes"})
+    @VisibleForTesting
+    static AtomicReference<TestcontainersConfiguration> getInstanceField() {
+        // Lazy Getter from Lombok changes the field's type to AtomicReference
+        return (AtomicReference) (Object) instance;
+    }
 
     @Getter(AccessLevel.NONE)
     private final Properties environmentProperties;

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

@@ -11,7 +11,7 @@
 import com.github.dockerjava.core.command.StartContainerCmdImpl;
 import lombok.RequiredArgsConstructor;
 import lombok.experimental.FieldDefaults;
-import org.junit.Assume;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.experimental.runners.Enclosed;
 import org.junit.runner.RunWith;
@@ -23,6 +23,7 @@
 import org.testcontainers.DockerClientFactory;
 import org.testcontainers.containers.startupcheck.StartupCheckStrategy;
 import org.testcontainers.containers.wait.strategy.AbstractWaitStrategy;
+import org.testcontainers.utility.MockTestcontainersConfigurationRule;
 import org.testcontainers.utility.TestcontainersConfiguration;
 
 import java.util.ArrayList;
@@ -128,9 +129,8 @@ protected void containerIsStarted(InspectContainerResponse containerInfo, boolea
 
         @Test
         public void shouldSetLabelsIfEnvironmentDoesNotSupportReuse() {
-            // TODO mock TestcontainersConfiguration
-            Assume.assumeFalse("does not support reuse", TestcontainersConfiguration.getInstance().environmentSupportsReuse());
-            AtomicReference<CreateContainerCmd> commandRef = new AtomicReference<>();
+            Mockito.doReturn(false).when(TestcontainersConfiguration.getInstance()).environmentSupportsReuse();
+
             String containerId = randomContainerId();
             when(client.createContainerCmd(any())).then(createContainerAnswer(containerId));
             when(client.listContainersCmd()).then(listContainersAnswer());
@@ -147,8 +147,7 @@ public void shouldSetLabelsIfEnvironmentDoesNotSupportReuse() {
 
         @Test
         public void shouldCallHookIfReused() {
-            // TODO mock TestcontainersConfiguration
-            Assume.assumeTrue("supports reuse", TestcontainersConfiguration.getInstance().environmentSupportsReuse());
+            Mockito.doReturn(true).when(TestcontainersConfiguration.getInstance()).environmentSupportsReuse();
             String containerId = randomContainerId();
             when(client.createContainerCmd(any())).then(createContainerAnswer(containerId));
             String existingContainerId = randomContainerId();
@@ -200,8 +199,7 @@ public void shouldStartIfListReturnsEmpty() {
 
         @Test
         public void shouldReuseIfListReturnsID() {
-            // TODO mock TestcontainersConfiguration
-            Assume.assumeTrue("supports reuse", TestcontainersConfiguration.getInstance().environmentSupportsReuse());
+            Mockito.doReturn(true).when(TestcontainersConfiguration.getInstance()).environmentSupportsReuse();
             String containerId = randomContainerId();
             when(client.createContainerCmd(any())).then(createContainerAnswer(containerId));
             String existingContainerId = randomContainerId();
@@ -216,8 +214,7 @@ public void shouldReuseIfListReturnsID() {
 
         @Test
         public void shouldSetLabelsIfEnvironmentDoesNotSupportReuse() {
-            // TODO mock TestcontainersConfiguration
-            Assume.assumeFalse("does not support reuse", TestcontainersConfiguration.getInstance().environmentSupportsReuse());
+            Mockito.doReturn(false).when(TestcontainersConfiguration.getInstance()).environmentSupportsReuse();
             AtomicReference<CreateContainerCmd> commandRef = new AtomicReference<>();
             String containerId = randomContainerId();
             when(client.createContainerCmd(any())).then(createContainerAnswer(containerId, commandRef::set));
@@ -236,19 +233,29 @@ public void shouldSetLabelsIfEnvironmentDoesNotSupportReuse() {
     }
 
     @FieldDefaults(makeFinal = true)
-    static abstract class AbstractReusabilityTest {
+    public static abstract class AbstractReusabilityTest {
+
+        @Rule
+        public MockTestcontainersConfigurationRule configurationMock = new MockTestcontainersConfigurationRule();
 
         protected DockerClient client = Mockito.mock(DockerClient.class);
 
         protected <T extends GenericContainer<?>> T makeReusable(T container) {
             container.dockerClient = client;
             container.withNetworkMode("none"); // to disable the port forwarding
             container.withStartupCheckStrategy(new StartupCheckStrategy() {
-                    @Override
-                    public StartupStatus checkStartupState(DockerClient dockerClient, String containerId) {
-                        return StartupStatus.SUCCESSFUL;
-                    }
-                });
+
+                @Override
+                public boolean waitUntilStartupSuccessful(DockerClient dockerClient, String containerId) {
+                    // Skip DockerClient rate limiter
+                    return true;
+                }
+
+                @Override
+                public StartupStatus checkStartupState(DockerClient dockerClient, String containerId) {
+                    return StartupStatus.SUCCESSFUL;
+                }
+            });
             container.waitingFor(new AbstractWaitStrategy() {
                     @Override
                     protected void waitUntilReady() {

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

@@ -0,0 +1,36 @@
+package org.testcontainers.utility;
+
+import org.jetbrains.annotations.NotNull;
+import org.junit.rules.TestRule;
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+import org.mockito.Mockito;
+
+import java.util.concurrent.atomic.AtomicReference;
+
+/**
+ * This {@link TestRule} applies a spy on {@link TestcontainersConfiguration}
+ * for testing features that depend on the global configuration.
+ */
+public class MockTestcontainersConfigurationRule implements TestRule {
+
+    static AtomicReference<TestcontainersConfiguration> REF = TestcontainersConfiguration.getInstanceField();
+
+    @NotNull
+    @Override
+    public Statement apply(@NotNull Statement base, @NotNull Description description) {
+        return new Statement() {
+            @Override
+            public void evaluate() throws Throwable {
+                TestcontainersConfiguration previous = REF.get();
+                REF.set(Mockito.spy(previous));
+
+                try {
+                    base.evaluate();
+                } finally {
+                    REF.set(previous);
+                }
+            }
+        };
+    }
+}