Couple integration tests for IPv6 support

Added tests to verify that driver can connect to real single-instance
database using localhost IPv6 address. Added test to check that driver
can receive IPv6 addresses in routing procedure response (using stub
server). Introduced convenience method to read server version using
given driver instance.

Author: lutovich

src/v1/internal/server-version.js

@@ -36,9 +36,22 @@ class ServerVersion {
     this.patch = patch;
   }
 
+  /**
+   * Fetch server version using the given driver.
+   * @param {Driver} driver the driver to use.
+   * @return {Promise<ServerVersion>} promise resolved with a {@link ServerVersion} object or rejected with error.
+   */
+  static fromDriver(driver) {
+    const session = driver.session();
+    return session.run('RETURN 1').then(result => {
+      session.close();
+      return ServerVersion.fromString(result.summary.server.version);
+    });
+  }
+
   /**
    * Parse given string to a {@link ServerVersion} object.
-   * @param versionStr the string to parse.
+   * @param {string} versionStr the string to parse.
    * @return {ServerVersion} version for the given string.
    * @throws Error if given string can't be parsed.
    */

test/internal/server-version.test.js

@@ -17,6 +17,8 @@
  * limitations under the License.
  */
 
+import neo4j from '../../src/v1';
+import sharedNeo4j from '../internal/shared-neo4j';
 import {ServerVersion, VERSION_3_2_0, VERSION_IN_DEV} from '../../src/v1/internal/server-version';
 
 describe('ServerVersion', () => {
@@ -80,6 +82,33 @@ describe('ServerVersion', () => {
     verifyVersion(parse('Neo4j/Dev'), 0, 0, 0);
   });
 
+  it('should fetch version using driver', done => {
+    const driver = neo4j.driver('bolt://localhost', sharedNeo4j.authToken);
+    ServerVersion.fromDriver(driver).then(version => {
+      driver.close();
+      expect(version).not.toBeNull();
+      expect(version).toBeDefined();
+      expect(version instanceof ServerVersion).toBeTruthy();
+      done();
+    }).catch(error => {
+      driver.close();
+      done.fail(error);
+    });
+  });
+
+  it('should fail to fetch version using incorrect driver', done => {
+    const driver = neo4j.driver('bolt://localhost:4242', sharedNeo4j.authToken); // use wrong port
+    ServerVersion.fromDriver(driver).then(version => {
+      driver.close();
+      done.fail('Should not be able to fetch version: ' + JSON.stringify(version));
+    }).catch(error => {
+      expect(error).not.toBeNull();
+      expect(error).toBeDefined();
+      driver.close();
+      done();
+    });
+  });
+
   it('should compare equal versions', () => {
     expect(new ServerVersion(3, 1, 0).compareTo(new ServerVersion(3, 1, 0))).toEqual(0);
     expect(new ServerVersion(1, 9, 12).compareTo(new ServerVersion(1, 9, 12))).toEqual(0);

test/internal/shared-neo4j.js

@@ -64,7 +64,13 @@ class SupportedPlatform extends UnsupportedPlatform {
   }
 
   spawn(command, args) {
-    return this._childProcess.spawnSync(command, args);
+    const options = {
+      // ignore stdin, use default values for stdout and stderr
+      // otherwise spawned java process does not see IPv6 address of the local interface and Neo4j fails to start
+      // https://github.com/nodejs/node-v0.x-archive/issues/7406
+      stdio: ['ignore', null, null]
+    };
+    return this._childProcess.spawnSync(command, args, options);
   }
 
   listDir(path) {
@@ -94,6 +100,11 @@ const username = 'neo4j';
 const password = 'password';
 const authToken = neo4j.auth.basic(username, password);
 
+const additionalConfig = {
+  // tell neo4j to listen for IPv6 connections, only supported by 3.1+
+  'dbms.connectors.default_listen_address': '::'
+};
+
 const neoCtrlVersionParam = '-e';
 const defaultNeo4jVersion = '3.2.5';
 const defaultNeoCtrlArgs = `${neoCtrlVersionParam} ${defaultNeo4jVersion}`;
@@ -113,6 +124,7 @@ function start(dir, givenNeoCtrlArgs) {
 
   if (boltKitCheckResult.successful) {
     const neo4jDir = installNeo4j(dir, givenNeoCtrlArgs);
+    configureNeo4j(neo4jDir);
     createDefaultUser(neo4jDir);
     startNeo4j(neo4jDir);
   } else {
@@ -158,6 +170,18 @@ function installNeo4j(dir, givenNeoCtrlArgs) {
   }
 }
 
+function configureNeo4j(neo4jDir) {
+  console.log('Configuring Neo4j at: \'' + neo4jDir + '\' with ' + JSON.stringify(additionalConfig));
+
+  const configEntries = Object.keys(additionalConfig).map(key => `${key}=${additionalConfig[key]}`);
+  const configureResult = runCommand('neoctrl-configure', [neo4jDir, ...configEntries]);
+  if (!configureResult.successful) {
+    throw new Error('Unable to configure Neo4j.\n' + configureResult.fullOutput);
+  }
+
+  console.log('Configured Neo4j at: \'' + neo4jDir + '\'');
+}
+
 function createDefaultUser(neo4jDir) {
   console.log('Creating user \'' + username + '\' for Neo4j at: \'' + neo4jDir + '\'');
   const result = runCommand('neoctrl-create-user', [neo4jDir, username, password]);

test/resources/boltstub/discover_ipv6_servers_and_read.script

@@ -0,0 +1,14 @@
+!: AUTO INIT
+!: AUTO RESET
+!: AUTO PULL_ALL
+
+C: RUN "CALL dbms.cluster.routing.getServers" {}
+   PULL_ALL
+S: SUCCESS {"fields": ["ttl", "servers"]}
+   RECORD [9223372036854775807, [{"addresses": ["127.0.0.1:9001", "[::1]:9001"],"role": "READ"}, {"addresses": ["[2001:db8:a0b:12f0::1]:9002","[3731:54:65fe:2::a7]:9003"], "role": "WRITE"},{"addresses": ["[ff02::1]:9001","[684D:1111:222:3333:4444:5555:6:77]:9002","[::1]:9003"], "role": "ROUTE"}]]
+   SUCCESS {}
+C: RUN "MATCH (n) RETURN n.name" {}
+   PULL_ALL
+S: SUCCESS {"fields": ["n.name"]}
+   SUCCESS {}
+

test/v1/driver.test.js

@@ -22,11 +22,22 @@ import sharedNeo4j from '../internal/shared-neo4j';
 import FakeConnection from '../internal/fake-connection';
 import lolex from 'lolex';
 import {DEFAULT_ACQUISITION_TIMEOUT, DEFAULT_MAX_SIZE} from '../../src/v1/internal/pool-config';
+import {ServerVersion, VERSION_3_1_0} from '../../src/v1/internal/server-version';
 
 describe('driver', () => {
 
   let clock;
   let driver;
+  let serverVersion;
+
+  beforeAll(done => {
+    const tmpDriver = neo4j.driver('bolt://localhost', sharedNeo4j.authToken);
+    ServerVersion.fromDriver(tmpDriver).then(version => {
+      tmpDriver.close();
+      serverVersion = version;
+      done();
+    });
+  });
 
   afterEach(() => {
     if (clock) {
@@ -39,13 +50,6 @@ describe('driver', () => {
     }
   });
 
-  fit('apa', done => {
-    driver = neo4j.driver('bolt://[::1]', sharedNeo4j.authToken);
-    driver.session().run('return 1').then(result => console.log(result.records))
-      .catch(error => console.log(error))
-      .then(() => done());
-  });
-
   it('should expose sessions', () => {
     // Given
     driver = neo4j.driver("bolt://localhost", sharedNeo4j.authToken);
@@ -313,6 +317,30 @@ describe('driver', () => {
     });
   });
 
+  it('should connect to IPv6 address without port', done => {
+    testIPv6Connection('bolt://[::1]', done);
+  });
+
+  it('should connect to IPv6 address wit port', done => {
+    testIPv6Connection('bolt://[::1]:7687', done);
+  });
+
+  function testIPv6Connection(url, done) {
+    if (serverVersion.compareTo(VERSION_3_1_0) < 0) {
+      // IPv6 listen address only supported starting from neo4j 3.1, so let's ignore the rest
+      done();
+    }
+
+    driver = neo4j.driver('bolt://[::1]', sharedNeo4j.authToken);
+
+    const session = driver.session();
+    session.run('RETURN 42').then(result => {
+      expect(result.records[0].get(0).toNumber()).toEqual(42);
+      session.close();
+      done();
+    });
+  }
+
   /**
    * Starts new transaction to force new network connection.
    * @param {Driver} driver - the driver to use.

test/v1/routing.driver.boltkit.test.js

@@ -38,7 +38,7 @@ describe('routing driver with stub server', () => {
     jasmine.DEFAULT_TIMEOUT_INTERVAL = originalTimeout;
   });
 
-  it('should discover server', done => {
+  it('should discover servers', done => {
     if (!boltStub.supported) {
       done();
       return;
@@ -68,6 +68,33 @@ describe('routing driver with stub server', () => {
     });
   });
 
+  it('should discover IPv6 servers', done => {
+    if (!boltStub.supported) {
+      done();
+      return;
+    }
+
+    const server = boltStub.start('./test/resources/boltstub/discover_ipv6_servers_and_read.script', 9001);
+
+    boltStub.run(() => {
+      const driver = boltStub.newDriver('bolt+routing://127.0.0.1:9001');
+      const session = driver.session(READ);
+      session.run('MATCH (n) RETURN n.name').then(() => {
+
+        expect(hasAddressInConnectionPool(driver, '127.0.0.1:9001')).toBeTruthy();
+        assertHasReaders(driver, ['127.0.0.1:9001', '[::1]:9001']);
+        assertHasWriters(driver, ['[2001:db8:a0b:12f0::1]:9002', '[3731:54:65fe:2::a7]:9003']);
+        assertHasRouters(driver, ['[ff02::1]:9001', '[684D:1111:222:3333:4444:5555:6:77]:9002', '[::1]:9003']);
+
+        driver.close();
+        server.exit(code => {
+          expect(code).toEqual(0);
+          done();
+        });
+      });
+    });
+  });
+
   it('should purge connections to stale servers after routing table refresh', done => {
     if (!boltStub.supported) {
       done();

test/v1/types.test.js

@@ -146,12 +146,10 @@ describe('byte arrays', () => {
   beforeAll(done => {
     jasmine.DEFAULT_TIMEOUT_INTERVAL = 60000;
 
-    const driver = neo4j.driver('bolt://localhost', sharedNeo4j.authToken);
-    const session = driver.session();
-    session.run('RETURN 1').then(result => {
-      driver.close();
-      const serverVersion = ServerVersion.fromString(result.summary.server.version);
-      serverSupportsByteArrays = serverVersion.compareTo(VERSION_3_2_0) >= 0;
+    const tmpDriver = neo4j.driver('bolt://localhost', sharedNeo4j.authToken);
+    ServerVersion.fromDriver(tmpDriver).then(version => {
+      tmpDriver.close();
+      serverSupportsByteArrays = version.compareTo(VERSION_3_2_0) >= 0;
       done();
     });
   });