Feature/neo4j defaults (#6154)

Co-authored-by: Kevin Wittek <[email protected]>

Author: meistermeier

modules/neo4j/src/main/java/org/testcontainers/containers/Neo4jContainer.java

@@ -66,6 +66,16 @@ public class Neo4jContainer<S extends Neo4jContainer<S>> extends GenericContaine
 
     private final Set<String> labsPlugins = new HashSet<>();
 
+    /**
+     * Default wait strategies
+     */
+    public static final WaitStrategy WAIT_FOR_BOLT = new LogMessageWaitStrategy()
+        .withRegEx(String.format(".*Bolt enabled on .*:%d\\.\n", DEFAULT_BOLT_PORT));
+
+    private static final WaitStrategy WAIT_FOR_HTTP = new HttpWaitStrategy()
+        .forPort(DEFAULT_HTTP_PORT)
+        .forStatusCodeMatching(response -> response == HttpURLConnection.HTTP_OK);
+
     /**
      * Creates a Neo4jContainer using the official Neo4j docker image.
      * @deprecated use {@link Neo4jContainer(DockerImageName)} instead
@@ -95,16 +105,10 @@ public Neo4jContainer(final DockerImageName dockerImageName) {
 
         dockerImageName.assertCompatibleWith(DEFAULT_IMAGE_NAME);
 
-        WaitStrategy waitForBolt = new LogMessageWaitStrategy()
-            .withRegEx(String.format(".*Bolt enabled on .*:%d\\.\n", DEFAULT_BOLT_PORT));
-        WaitStrategy waitForHttp = new HttpWaitStrategy()
-            .forPort(DEFAULT_HTTP_PORT)
-            .forStatusCodeMatching(response -> response == HttpURLConnection.HTTP_OK);
-
         this.waitStrategy =
             new WaitAllStrategy()
-                .withStrategy(waitForBolt)
-                .withStrategy(waitForHttp)
+                .withStrategy(WAIT_FOR_BOLT)
+                .withStrategy(WAIT_FOR_HTTP)
                 .withStartupTimeout(Duration.ofMinutes(2));
 
         addExposedPorts(DEFAULT_BOLT_PORT, DEFAULT_HTTP_PORT, DEFAULT_HTTPS_PORT);
@@ -120,15 +124,56 @@ public Set<Integer> getLivenessCheckPortNumbers() {
 
     @Override
     protected void configure() {
-        boolean emptyAdminPassword = this.adminPassword == null || this.adminPassword.isEmpty();
-        String neo4jAuth = emptyAdminPassword ? "none" : String.format(AUTH_FORMAT, this.adminPassword);
-        addEnv("NEO4J_AUTH", neo4jAuth);
+        configureAuth();
+        configureLabsPlugins();
+        configureWaitStrategy();
+    }
+
+    /**
+     * Configured via {@link Neo4jContainer#withAdminPassword(String)} or {@link Neo4jContainer#withoutAuthentication()}
+     * It is only possible to set the correct auth in the configuration call.
+     * Also, the custom methods overrule the set env parameter.
+     */
+    private void configureAuth() {
+        String neo4jAuthEnvKey = "NEO4J_AUTH";
+        if (!getEnvMap().containsKey(neo4jAuthEnvKey) || !DEFAULT_ADMIN_PASSWORD.equals(this.adminPassword)) {
+            boolean emptyAdminPassword = this.adminPassword == null || this.adminPassword.isEmpty();
+            String neo4jAuth = emptyAdminPassword ? "none" : String.format(AUTH_FORMAT, this.adminPassword);
+            addEnv(neo4jAuthEnvKey, neo4jAuth);
+        }
+    }
 
-        if (!this.labsPlugins.isEmpty()) {
+    /**
+     * Configured via {@link Neo4jContainer#withLabsPlugins}.
+     * Configuration can only happen in the configuration call because there is no default.
+     */
+    private void configureLabsPlugins() {
+        String neo4jLabsPluginsEnvKey = "NEO4JLABS_PLUGINS";
+        if (!getEnv().contains(neo4jLabsPluginsEnvKey) && !this.labsPlugins.isEmpty()) {
             String enabledPlugins =
                 this.labsPlugins.stream().map(pluginName -> "\"" + pluginName + "\"").collect(Collectors.joining(","));
 
-            addEnv("NEO4JLABS_PLUGINS", "[" + enabledPlugins + "]");
+            addEnv(neo4jLabsPluginsEnvKey, "[" + enabledPlugins + "]");
+        }
+    }
+
+    /**
+     * Update the default Neo4jContainer wait strategy based on the exposed ports.
+     * Still possible to override the startup timeout before starting the container via {@link WaitStrategy#withStartupTimeout(Duration)}.
+     */
+    private void configureWaitStrategy() {
+        List<Integer> exposedPorts = getExposedPorts();
+        boolean boltExposed = exposedPorts.contains(DEFAULT_BOLT_PORT);
+        boolean httpExposed = exposedPorts.contains(DEFAULT_HTTP_PORT);
+        boolean onlyBoltExposed = boltExposed && !httpExposed;
+        boolean onlyHttpExposed = !boltExposed && httpExposed;
+
+        if (onlyBoltExposed) {
+            this.waitStrategy =
+                new WaitAllStrategy().withStrategy(WAIT_FOR_BOLT).withStartupTimeout(Duration.ofMinutes(2));
+        } else if (onlyHttpExposed) {
+            this.waitStrategy =
+                new WaitAllStrategy().withStrategy(WAIT_FOR_HTTP).withStartupTimeout(Duration.ofMinutes(2));
         }
     }
 

modules/neo4j/src/test/java/org/testcontainers/containers/Neo4jContainerTest.java

@@ -8,6 +8,8 @@
 import org.neo4j.driver.Record;
 import org.neo4j.driver.Result;
 import org.neo4j.driver.Session;
+import org.testcontainers.DockerClientFactory;
+import org.testcontainers.containers.wait.strategy.AbstractWaitStrategy;
 import org.testcontainers.utility.MountableFile;
 
 import java.util.Collections;
@@ -45,6 +47,8 @@ public void shouldDisableAuthentication() {
 
     @Test
     public void shouldCopyDatabase() {
+        // no aarch64 image available for Neo4j 3.5
+        assumeThat(DockerClientFactory.instance().getInfo().getArchitecture()).isNotEqualTo("aarch64");
         try (
             // copyDatabase {
             Neo4jContainer<?> neo4jContainer = new Neo4jContainer<>("neo4j:3.5.30")
@@ -169,6 +173,82 @@ public void shouldAddConfigToEnvironment() {
         assertThat(neo4jContainer.getEnvMap()).containsEntry("NEO4J_dbms_tx__log_rotation_size", "42M");
     }
 
+    @Test
+    public void shouldRespectEnvironmentAuth() {
+        Neo4jContainer<?> neo4jContainer = new Neo4jContainer<>("neo4j:4.4").withEnv("NEO4J_AUTH", "neo4j/secret");
+
+        neo4jContainer.configure();
+
+        assertThat(neo4jContainer.getEnvMap()).containsEntry("NEO4J_AUTH", "neo4j/secret");
+    }
+
+    @Test
+    public void containerAdminPasswordOverrulesEnvironmentAuth() {
+        Neo4jContainer<?> neo4jContainer = new Neo4jContainer<>("neo4j:4.4")
+            .withEnv("NEO4J_AUTH", "neo4j/secret")
+            .withAdminPassword("anotherSecret");
+
+        neo4jContainer.configure();
+
+        assertThat(neo4jContainer.getEnvMap()).containsEntry("NEO4J_AUTH", "neo4j/anotherSecret");
+    }
+
+    @Test
+    public void containerWithoutAuthenticationOverrulesEnvironmentAuth() {
+        Neo4jContainer<?> neo4jContainer = new Neo4jContainer<>("neo4j:4.4")
+            .withEnv("NEO4J_AUTH", "neo4j/secret")
+            .withoutAuthentication();
+
+        neo4jContainer.configure();
+
+        assertThat(neo4jContainer.getEnvMap()).containsEntry("NEO4J_AUTH", "none");
+    }
+
+    @Test
+    public void shouldRespectAlreadyDefinedPortMappingsBolt() {
+        Neo4jContainer<?> neo4jContainer = new Neo4jContainer<>("neo4j:4.4").withExposedPorts(7687);
+
+        neo4jContainer.configure();
+
+        assertThat(neo4jContainer.getExposedPorts()).containsExactly(7687);
+    }
+
+    @Test
+    public void shouldRespectAlreadyDefinedPortMappingsHttp() {
+        Neo4jContainer<?> neo4jContainer = new Neo4jContainer<>("neo4j:4.4").withExposedPorts(7474);
+
+        neo4jContainer.configure();
+
+        assertThat(neo4jContainer.getExposedPorts()).containsExactly(7474);
+    }
+
+    @Test
+    public void shouldRespectAlreadyDefinedPortMappingsWithoutHttps() {
+        Neo4jContainer<?> neo4jContainer = new Neo4jContainer<>("neo4j:4.4").withExposedPorts(7687, 7474);
+
+        neo4jContainer.configure();
+
+        assertThat(neo4jContainer.getExposedPorts()).containsExactlyInAnyOrder(7474, 7687);
+    }
+
+    @Test
+    public void shouldDefaultExportBoltHttpAndHttps() {
+        Neo4jContainer<?> neo4jContainer = new Neo4jContainer<>("neo4j:4.4");
+
+        neo4jContainer.configure();
+
+        assertThat(neo4jContainer.getExposedPorts()).containsExactlyInAnyOrder(7473, 7474, 7687);
+    }
+
+    @Test
+    public void shouldRespectCustomWaitStrategy() {
+        Neo4jContainer<?> neo4jContainer = new Neo4jContainer<>("neo4j:4.4").waitingFor(new CustomDummyWaitStrategy());
+
+        neo4jContainer.configure();
+
+        assertThat(neo4jContainer.getWaitStrategy()).isInstanceOf(CustomDummyWaitStrategy.class);
+    }
+
     @Test
     public void shouldConfigureSingleLabsPlugin() {
         try (
@@ -220,6 +300,14 @@ public void shouldConfigureMultipleLabsPluginsWithString() {
         }
     }
 
+    private static class CustomDummyWaitStrategy extends AbstractWaitStrategy {
+
+        @Override
+        protected void waitUntilReady() {
+            // ehm...ready
+        }
+    }
+
     private static Driver getDriver(Neo4jContainer<?> container) {
         AuthToken authToken = AuthTokens.none();
         if (container.getAdminPassword() != null) {