Migrate tests depending on Boltkit to use Docker

README.md

@@ -97,19 +97,18 @@ To use the driver in a project, please use the released driver via Maven Central
 
 #### Running Tests and Creating a Package
 
-Our test setup requires a bit of infrastructure to run.
-We rely mostly on [`testkit`](https://github.com/neo4j-drivers/testkit).
-Testkit is a tooling that is used to run integration tests for all of the drivers we provide.
-
-Some older tests still rely on [`boltkit`](https://github.com/neo4j-drivers/boltkit), the predecessor to Testkit.
-If `boltkit` is not installed, then all tests that requires `boltkit` will be ignored and will not be executed.
-
-In case you want or can verify contributions with unit tests alone, use the following command to skip all integration and Testkit tests:
-
+The following command may be used to unit test and install artifacts without running integration tests:
 ```
 mvn clean install -DskipITs -P skip-testkit
 ```
 
+Integration tests have the following prerequisites:
+- Docker
+- [`Testkit`](https://github.com/neo4j-drivers/testkit)
+
+Testkit that is a tooling that is used to run integration tests for all official Neo4j drivers.
+It can be executed using Docker during Maven build and in such case does not require additional setup. See the instructions below for more details.
+
 There are 2 ways of running Testkit tests:
 1. Using the `testkit-tests` module of this project.
 2. Manually cloning Testkit and running it directly.

driver/pom.xml

@@ -100,6 +100,10 @@
       <groupId>org.reactivestreams</groupId>
       <artifactId>reactive-streams-tck</artifactId>
     </dependency>
+    <dependency>
+      <groupId>ch.qos.logback</groupId>
+      <artifactId>logback-classic</artifactId>
+    </dependency>
   </dependencies>
 
   <build>

driver/src/test/java/org/neo4j/driver/integration/ConnectionPoolIT.java

@@ -80,7 +80,8 @@ void shouldRecoverFromDownedServer() throws Throwable {
         sessionGrabber.start();
 
         // When
-        neo4j.forceRestartDb();
+        neo4j.stopProxy();
+        neo4j.startProxy();
 
         // Then we accept a hump with failing sessions, but demand that failures stop as soon as the server is back up.
         sessionGrabber.assertSessionsAvailableWithin(120);

driver/src/test/java/org/neo4j/driver/integration/CredentialsIT.java

@@ -25,13 +25,8 @@
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.neo4j.driver.AuthTokens.basic;
 import static org.neo4j.driver.AuthTokens.custom;
-import static org.neo4j.driver.Values.ofValue;
-import static org.neo4j.driver.Values.parameters;
 import static org.neo4j.driver.internal.logging.DevNullLogging.DEV_NULL_LOGGING;
-import static org.neo4j.driver.util.Neo4jRunner.PASSWORD;
 
-import java.nio.file.Files;
-import java.nio.file.Paths;
 import java.util.Map;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
@@ -44,58 +39,18 @@
 import org.neo4j.driver.Value;
 import org.neo4j.driver.exceptions.AuthenticationException;
 import org.neo4j.driver.exceptions.SecurityException;
-import org.neo4j.driver.internal.security.InternalAuthToken;
-import org.neo4j.driver.internal.util.DisabledOnNeo4jWith;
-import org.neo4j.driver.internal.util.Neo4jFeature;
 import org.neo4j.driver.util.DatabaseExtension;
-import org.neo4j.driver.util.Neo4jSettings;
 import org.neo4j.driver.util.ParallelizableIT;
 
 @ParallelizableIT
 class CredentialsIT {
     @RegisterExtension
     static final DatabaseExtension neo4j = new DatabaseExtension();
 
-    @Test
-    @DisabledOnNeo4jWith(Neo4jFeature.BOLT_V4)
-    // This feature is removed in 4.0
-    void shouldBePossibleToChangePassword() throws Exception {
-        String newPassword = "secret";
-        String tmpDataDir = Files.createTempDirectory(Paths.get("target"), "tmp")
-                .toAbsolutePath()
-                .toString()
-                .replace("\\", "/");
-
-        neo4j.restartDb(Neo4jSettings.TEST_SETTINGS.updateWith(Neo4jSettings.DATA_DIR, tmpDataDir));
-
-        AuthToken authToken = new InternalAuthToken(parameters(
-                        "scheme", "basic",
-                        "principal", "neo4j",
-                        "credentials", "neo4j",
-                        "new_credentials", newPassword)
-                .asMap(ofValue()));
-
-        // change the password
-        try (Driver driver = GraphDatabase.driver(neo4j.uri(), authToken);
-                Session session = driver.session()) {
-            session.run("RETURN 1").consume();
-        }
-
-        // verify old password does not work
-        final Driver badDriver = GraphDatabase.driver(CredentialsIT.neo4j.uri(), basic("neo4j", PASSWORD));
-        assertThrows(AuthenticationException.class, badDriver::verifyConnectivity);
-
-        // verify new password works
-        try (Driver driver = GraphDatabase.driver(CredentialsIT.neo4j.uri(), AuthTokens.basic("neo4j", newPassword));
-                Session session = driver.session()) {
-            session.run("RETURN 2").consume();
-        }
-    }
-
     @Test
     void basicCredentialsShouldWork() {
         // When & Then
-        try (Driver driver = GraphDatabase.driver(neo4j.uri(), basic("neo4j", PASSWORD));
+        try (Driver driver = GraphDatabase.driver(neo4j.uri(), basic("neo4j", neo4j.adminPassword()));
                 Session session = driver.session()) {
             Value single = session.run("RETURN 1").single().get(0);
             assertThat(single.asLong(), equalTo(1L));
@@ -105,7 +60,8 @@ void basicCredentialsShouldWork() {
     @Test
     void shouldGetHelpfulErrorOnInvalidCredentials() {
         SecurityException e = assertThrows(SecurityException.class, () -> {
-            try (Driver driver = GraphDatabase.driver(neo4j.uri(), basic("thisisnotthepassword", PASSWORD));
+            try (Driver driver =
+                            GraphDatabase.driver(neo4j.uri(), basic("thisisnotthepassword", neo4j.adminPassword()));
                     Session session = driver.session()) {
                 session.run("RETURN 1");
             }
@@ -116,7 +72,7 @@ void shouldGetHelpfulErrorOnInvalidCredentials() {
     @Test
     void shouldBeAbleToProvideRealmWithBasicAuth() {
         // When & Then
-        try (Driver driver = GraphDatabase.driver(neo4j.uri(), basic("neo4j", PASSWORD, "native"));
+        try (Driver driver = GraphDatabase.driver(neo4j.uri(), basic("neo4j", neo4j.adminPassword(), "native"));
                 Session session = driver.session()) {
             Value single = session.run("CREATE () RETURN 1").single().get(0);
             assertThat(single.asLong(), equalTo(1L));
@@ -126,7 +82,8 @@ void shouldBeAbleToProvideRealmWithBasicAuth() {
     @Test
     void shouldBeAbleToConnectWithCustomToken() {
         // When & Then
-        try (Driver driver = GraphDatabase.driver(neo4j.uri(), custom("neo4j", PASSWORD, "native", "basic"));
+        try (Driver driver =
+                        GraphDatabase.driver(neo4j.uri(), custom("neo4j", neo4j.adminPassword(), "native", "basic"));
                 Session session = driver.session()) {
             Value single = session.run("CREATE () RETURN 1").single().get(0);
             assertThat(single.asLong(), equalTo(1L));
@@ -138,7 +95,8 @@ void shouldBeAbleToConnectWithCustomTokenWithAdditionalParameters() {
         Map<String, Object> params = singletonMap("secret", 16);
 
         // When & Then
-        try (Driver driver = GraphDatabase.driver(neo4j.uri(), custom("neo4j", PASSWORD, "native", "basic", params));
+        try (Driver driver = GraphDatabase.driver(
+                        neo4j.uri(), custom("neo4j", neo4j.adminPassword(), "native", "basic", params));
                 Session session = driver.session()) {
             Value single = session.run("CREATE () RETURN 1").single().get(0);
             assertThat(single.asLong(), equalTo(1L));
@@ -147,12 +105,12 @@ void shouldBeAbleToConnectWithCustomTokenWithAdditionalParameters() {
 
     @Test
     void directDriverShouldFailEarlyOnWrongCredentials() {
-        testDriverFailureOnWrongCredentials("bolt://localhost:" + neo4j.boltPort());
+        testDriverFailureOnWrongCredentials(neo4j.uri().toString());
     }
 
     @Test
     void routingDriverShouldFailEarlyOnWrongCredentials() {
-        testDriverFailureOnWrongCredentials("neo4j://localhost:" + neo4j.boltPort());
+        testDriverFailureOnWrongCredentials(neo4j.uri().toString());
     }
 
     private void testDriverFailureOnWrongCredentials(String uri) {

driver/src/test/java/org/neo4j/driver/integration/DirectDriverIT.java

@@ -25,14 +25,11 @@
 import static org.neo4j.driver.internal.util.Matchers.directDriverWithAddress;
 
 import java.net.URI;
-import org.hamcrest.CoreMatchers;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
 import org.neo4j.driver.Driver;
 import org.neo4j.driver.GraphDatabase;
-import org.neo4j.driver.Result;
-import org.neo4j.driver.Session;
 import org.neo4j.driver.internal.BoltServerAddress;
 import org.neo4j.driver.util.DatabaseExtension;
 import org.neo4j.driver.util.ParallelizableIT;
@@ -87,17 +84,4 @@ void shouldRegisterSingleServer() {
         // Then
         assertThat(driver, is(directDriverWithAddress(address)));
     }
-
-    @Test
-    void shouldConnectIPv6Uri() {
-        // Given
-        try (Driver driver = GraphDatabase.driver("bolt://[::1]:" + neo4j.boltPort(), neo4j.authToken());
-                Session session = driver.session()) {
-            // When
-            Result result = session.run("RETURN 1");
-
-            // Then
-            assertThat(result.single().get(0).asInt(), CoreMatchers.equalTo(1));
-        }
-    }
 }

driver/src/test/java/org/neo4j/driver/integration/EncryptionIT.java

@@ -25,6 +25,8 @@
 import static org.neo4j.driver.Config.TrustStrategy.trustAllCertificates;
 
 import java.net.URI;
+import java.util.HashMap;
+import java.util.Map;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
 import org.neo4j.driver.Config;
@@ -81,7 +83,9 @@ void shouldOperateWithoutEncryptionWhenItIsAlsoDisabledInTheDatabase() {
     }
 
     private void testMatchingEncryption(BoltTlsLevel tlsLevel, boolean driverEncrypted, String scheme) {
-        neo4j.restartDb(Neo4jSettings.TEST_SETTINGS.updateWith(Neo4jSettings.BOLT_TLS_LEVEL, tlsLevel.toString()));
+        Map<String, String> tlsConfig = new HashMap<>();
+        tlsConfig.put(Neo4jSettings.BOLT_TLS_LEVEL, tlsLevel.toString());
+        neo4j.deleteAndStartNeo4j(tlsConfig);
         Config config;
 
         if (scheme.equals(Scheme.BOLT_LOW_TRUST_URI_SCHEME)) {
@@ -107,7 +111,9 @@ private void testMatchingEncryption(BoltTlsLevel tlsLevel, boolean driverEncrypt
     }
 
     private void testMismatchingEncryption(BoltTlsLevel tlsLevel, boolean driverEncrypted) {
-        neo4j.restartDb(Neo4jSettings.TEST_SETTINGS.updateWith(Neo4jSettings.BOLT_TLS_LEVEL, tlsLevel.toString()));
+        Map<String, String> tlsConfig = new HashMap<>();
+        tlsConfig.put(Neo4jSettings.BOLT_TLS_LEVEL, tlsLevel.toString());
+        neo4j.deleteAndStartNeo4j(tlsConfig);
         Config config = newConfig(driverEncrypted);
 
         ServiceUnavailableException e = assertThrows(

driver/src/test/java/org/neo4j/driver/integration/ErrorIT.java

@@ -177,13 +177,12 @@ void shouldHandleFailureAtRunTime() {
     }
 
     @Test
-    void shouldGetHelpfulErrorWhenTryingToConnectToHttpPort() throws Throwable {
-        // the http server needs some time to start up
-        Thread.sleep(2000);
-
+    void shouldGetHelpfulErrorWhenTryingToConnectToHttpPort() {
         Config config = Config.builder().withoutEncryption().build();
 
-        final Driver driver = GraphDatabase.driver("bolt://localhost:" + session.httpPort(), config);
+        URI boltUri = session.uri();
+        URI uri = URI.create(String.format("%s://%s:%d", boltUri.getScheme(), boltUri.getHost(), session.httpPort()));
+        final Driver driver = GraphDatabase.driver(uri, config);
         ClientException e = assertThrows(ClientException.class, driver::verifyConnectivity);
         assertEquals(
                 "Server responded HTTP. Make sure you are not trying to connect to the http endpoint "

driver/src/test/java/org/neo4j/driver/integration/LoadCSVIT.java

@@ -31,14 +31,12 @@
 import org.neo4j.driver.Result;
 import org.neo4j.driver.Session;
 import org.neo4j.driver.util.DatabaseExtension;
-import org.neo4j.driver.util.Neo4jSettings;
 import org.neo4j.driver.util.ParallelizableIT;
 
 @ParallelizableIT
 class LoadCSVIT {
     @RegisterExtension
-    static final DatabaseExtension neo4j = new DatabaseExtension(
-            Neo4jSettings.TEST_SETTINGS.without(Neo4jSettings.IMPORT_DIR).without(Neo4jSettings.SERVER_IMPORT_DIR));
+    static final DatabaseExtension neo4j = new DatabaseExtension();
 
     @Test
     void shouldLoadCSV() throws Throwable {
@@ -74,7 +72,7 @@ private String createLocalIrisData(Session session) throws IOException {
             session.run("CREATE (c:Class {name: $className}) RETURN c", parameters("className", className));
         }
 
-        return neo4j.putTmpFile("iris", ".csv", IRIS_DATA).toExternalForm();
+        return neo4j.addImportFile("iris", ".csv", IRIS_DATA);
     }
 
     private static String[] IRIS_CLASS_NAMES = new String[] {"Iris-setosa", "Iris-versicolor", "Iris-virginica"};

driver/src/test/java/org/neo4j/driver/integration/ServerKilledIT.java

@@ -21,7 +21,6 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.fail;
 import static org.neo4j.driver.Config.TrustStrategy.trustCustomCertificateSignedBy;
-import static org.neo4j.driver.util.Neo4jRunner.DEFAULT_AUTH_TOKEN;
 
 import java.util.List;
 import java.util.concurrent.TimeUnit;
@@ -69,11 +68,12 @@ private static Stream<Arguments> data() {
     @MethodSource("data")
     void shouldRecoverFromServerRestart(String name, Config.ConfigBuilder configBuilder) {
         // Given config with sessionLivenessCheckTimeout not set, i.e. turned off
-        try (Driver driver = GraphDatabase.driver(neo4j.uri(), DEFAULT_AUTH_TOKEN, configBuilder.build())) {
+        try (Driver driver = GraphDatabase.driver(neo4j.uri(), neo4j.authToken(), configBuilder.build())) {
             acquireAndReleaseConnections(4, driver);
 
             // When
-            neo4j.forceRestartDb();
+            neo4j.stopProxy();
+            neo4j.startProxy();
 
             // Then we should be able to start using sessions again, at most O(numSessions) session calls later
             int toleratedFailures = 4;
@@ -102,8 +102,9 @@ void shouldDropBrokenOldSessions(String name, Config.ConfigBuilder configBuilder
         try (Driver driver = createDriver(clock, configBuilder.build())) {
             acquireAndReleaseConnections(5, driver);
 
-            // restart database to invalidate all idle connections in the pool
-            neo4j.forceRestartDb();
+            // restart database access to invalidate all idle connections in the pool
+            neo4j.stopProxy();
+            neo4j.startProxy();
             // move clock forward more than configured liveness check timeout
             clock.progress(TimeUnit.MINUTES.toMillis(livenessCheckTimeoutMinutes + 1));
 
@@ -131,6 +132,6 @@ private Driver createDriver(Clock clock, Config config) {
         RoutingSettings routingSettings = RoutingSettings.DEFAULT;
         RetrySettings retrySettings = RetrySettings.DEFAULT;
         return factory.newInstance(
-                neo4j.uri(), DEFAULT_AUTH_TOKEN, routingSettings, retrySettings, config, SecurityPlanImpl.insecure());
+                neo4j.uri(), neo4j.authToken(), routingSettings, retrySettings, config, SecurityPlanImpl.insecure());
     }
 }

driver/src/test/java/org/neo4j/driver/integration/SessionIT.java

@@ -50,7 +50,6 @@
 import static org.neo4j.driver.internal.util.Matchers.connectionAcquisitionTimeoutError;
 import static org.neo4j.driver.internal.util.Neo4jFeature.BOLT_V4;
 import static org.neo4j.driver.util.DaemonThreadFactory.daemon;
-import static org.neo4j.driver.util.Neo4jRunner.DEFAULT_AUTH_TOKEN;
 
 import java.util.HashSet;
 import java.util.List;
@@ -1247,10 +1246,9 @@ private Driver newDriverWithoutRetries() {
 
     private Driver newDriverWithFixedRetries(int maxRetriesCount) {
         DriverFactory driverFactory = new DriverFactoryWithFixedRetryLogic(maxRetriesCount);
-        AuthToken auth = DEFAULT_AUTH_TOKEN;
         return driverFactory.newInstance(
                 neo4j.uri(),
-                auth,
+                neo4j.authToken(),
                 RoutingSettings.DEFAULT,
                 RetrySettings.DEFAULT,
                 noLoggingConfig(),

driver/src/test/java/org/neo4j/driver/integration/TrustCustomCertificateIT.java

@@ -24,6 +24,7 @@
 import static org.neo4j.driver.Config.TrustStrategy.trustCustomCertificateSignedBy;
 import static org.neo4j.driver.util.CertificateUtil.createNewCertificateAndKey;
 import static org.neo4j.driver.util.CertificateUtil.createNewCertificateAndKeySignedBy;
+import static org.neo4j.driver.util.DatabaseExtension.getDockerHostGeneralName;
 
 import java.io.File;
 import java.util.function.Supplier;
@@ -35,31 +36,30 @@
 import org.neo4j.driver.Result;
 import org.neo4j.driver.Session;
 import org.neo4j.driver.exceptions.SecurityException;
-import org.neo4j.driver.util.CertificateExtension;
 import org.neo4j.driver.util.CertificateUtil.CertificateKeyPair;
 import org.neo4j.driver.util.DatabaseExtension;
 import org.neo4j.driver.util.ParallelizableIT;
 
 @ParallelizableIT
 class TrustCustomCertificateIT {
     @RegisterExtension
-    static final DatabaseExtension neo4j = new CertificateExtension();
+    static final DatabaseExtension neo4j = new DatabaseExtension();
 
     @Test
     void shouldAcceptServerWithCertificateSignedByDriverCertificate() throws Throwable {
         // Given root certificate
         CertificateKeyPair<File, File> root = createNewCertificateAndKey();
 
         // When
-        CertificateKeyPair<File, File> server = createNewCertificateAndKeySignedBy(root);
+        CertificateKeyPair<File, File> server = createNewCertificateAndKeySignedBy(root, getDockerHostGeneralName());
         neo4j.updateEncryptionKeyAndCert(server.key(), server.cert());
 
         // Then
         shouldBeAbleToRunCypher(() -> createDriverWithCustomCertificate(root.cert()));
     }
 
     @Test
-    void shouldAcceptServerWithSameCertificate() throws Throwable {
+    void shouldAcceptServerWithSameCertificate() {
         shouldBeAbleToRunCypher(() -> createDriverWithCustomCertificate(neo4j.tlsCertFile()));
     }
 
@@ -70,7 +70,7 @@ void shouldRejectServerWithUntrustedCertificate() throws Throwable {
 
         // When & Then
         final Driver driver = createDriverWithCustomCertificate(certificateAndKey.cert());
-        SecurityException error = assertThrows(SecurityException.class, driver::verifyConnectivity);
+        assertThrows(SecurityException.class, driver::verifyConnectivity);
     }
 
     private void shouldBeAbleToRunCypher(Supplier<Driver> driverSupplier) {