Fix HELLO message RoutingContext

The routing context was missing information about the initial routing server. This information is important for the server side routing.

Author: bigmontz

bolt-connection/src/bolt/bolt-protocol-v4x0.js

@@ -156,7 +156,7 @@ export default class BoltProtocol extends BoltProtocolV3 {
     const resultObserver = this.run(
       CALL_GET_ROUTING_TABLE_MULTI_DB,
       {
-        [CONTEXT]: { ...routingContext, address: initialAddress },
+        [CONTEXT]: routingContext,
         [DATABASE]: databaseName
       },
       { ...sessionContext, txConfig: TxConfig.empty() }

bolt-connection/src/bolt/bolt-protocol-v4x3.js

@@ -56,10 +56,7 @@ export default class BoltProtocol extends BoltProtocolV42 {
     })
 
     this.write(
-      RequestMessage.route(
-        { ...routingContext, address: initialAddress },
-        databaseName
-      ),
+      RequestMessage.route(routingContext, databaseName),
       observer,
       true
     )

bolt-connection/src/bolt/request-message.js

@@ -108,7 +108,7 @@ export default class RequestMessage {
    */
   static hello (userAgent, authToken, routing = null) {
     const metadata = Object.assign({ user_agent: userAgent }, authToken)
-    if (routing != null) {
+    if (routing) {
       metadata.routing = routing
     }
     return new RequestMessage(

bolt-connection/src/connection-provider/connection-provider-routing.js

@@ -65,12 +65,13 @@ export default class RoutingConnectionProvider extends PooledConnectionProvider
         this._config,
         this._createConnectionErrorHandler(),
         this._log,
-        routingContext || {}
+        this._routingContext
       )
     })
 
+    this._routingContext = { ...routingContext, address: address.toString() }
     this._seedRouter = address
-    this._rediscovery = new Rediscovery(routingContext, address.toString())
+    this._rediscovery = new Rediscovery(this._routingContext)
     this._loadBalancingStrategy = new LeastConnectedLoadBalancingStrategy(
       this._connectionPool
     )

bolt-connection/src/rediscovery/rediscovery.js

@@ -28,11 +28,9 @@ export default class Rediscovery {
   /**
    * @constructor
    * @param {object} routingContext
-   * @param {string} initialAddress
    */
-  constructor (routingContext, initialAddress) {
+  constructor (routingContext) {
     this._routingContext = routingContext
-    this._initialAddress = initialAddress
   }
 
   /**
@@ -66,7 +64,6 @@ export default class Rediscovery {
     return new Promise((resolve, reject) => {
       connection.protocol().requestRoutingInformation({
         routingContext: this._routingContext,
-        initialAddress: this._initialAddress,
         databaseName: database,
         sessionContext: {
           bookmark: session._lastBookmark,

bolt-connection/test/bolt/bolt-protocol-v4x0.test.js

@@ -146,7 +146,7 @@ describe('#unit BoltProtocolV4x0', () => {
     expect(protocol._run[0]).toEqual([
       'CALL dbms.routing.getRoutingTable($context, $database)',
       {
-        context: { ...routingContext, address: initialAddress },
+        context: routingContext,
         database: databaseName
       },
       { ...sessionContext, txConfig: TxConfig.empty() }

bolt-connection/test/bolt/bolt-protocol-v4x3.test.js

@@ -49,7 +49,7 @@ describe('#unit BoltProtocolV4x3', () => {
 
     protocol.verifyMessageCount(1)
     expect(protocol.messages[0]).toBeMessage(
-      RequestMessage.route({ ...routingContext, address: null }, databaseName)
+      RequestMessage.route(routingContext, databaseName)
     )
     expect(protocol.observers).toEqual([observer])
     expect(observer).toEqual(jasmine.any(RouteObserver))

bolt-connection/test/fake-connection.js

@@ -0,0 +1,143 @@
+/**
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Connection from '../src/connection/connection'
+
+/**
+ * This class is like a mock of {@link Connection} that tracks invocations count.
+ * It tries to maintain same "interface" as {@link Connection}.
+ * It could be replaced with a proper mock by a library like testdouble.
+ * At the time of writing such libraries require {@link Proxy} support but browser tests execute in
+ * PhantomJS which does not support proxies.
+ */
+export default class FakeConnection extends Connection {
+  constructor () {
+    super(null)
+
+    this._open = true
+    this._id = 0
+    this._databaseId = null
+    this._requestRoutingInformationMock = null
+    this.creationTimestamp = Date.now()
+
+    this.resetInvoked = 0
+    this.releaseInvoked = 0
+    this.seenQueries = []
+    this.seenParameters = []
+    this.seenProtocolOptions = []
+    this._server = {}
+    this.protocolVersion = undefined
+    this.protocolErrorsHandled = 0
+    this.seenProtocolErrors = []
+    this.seenRequestRoutingInformation = []
+  }
+
+  get id () {
+    return this._id
+  }
+
+  get databaseId () {
+    return this._databaseId
+  }
+
+  set databaseId (value) {
+    this._databaseId = value
+  }
+
+  get server () {
+    return this._server
+  }
+
+  get version () {
+    return this._server.version
+  }
+
+  set version (value) {
+    this._server.version = value
+  }
+
+  protocol () {
+    // return fake protocol object that simply records seen queries and parameters
+    return {
+      run: (query, parameters, protocolOptions) => {
+        this.seenQueries.push(query)
+        this.seenParameters.push(parameters)
+        this.seenProtocolOptions.push(protocolOptions)
+      },
+      requestRoutingInformation: params => {
+        this.seenRequestRoutingInformation.push(params)
+        if (this._requestRoutingInformationMock) {
+          this._requestRoutingInformationMock(params)
+        }
+      },
+      version: this.protocolVersion
+    }
+  }
+
+  resetAndFlush () {
+    this.resetInvoked++
+    return Promise.resolve()
+  }
+
+  _release () {
+    this.releaseInvoked++
+    return Promise.resolve()
+  }
+
+  isOpen () {
+    return this._open
+  }
+
+  isNeverReleased () {
+    return this.isReleasedTimes(0)
+  }
+
+  isReleasedOnce () {
+    return this.isReleasedTimes(1)
+  }
+
+  isReleasedTimes (times) {
+    return this.resetInvoked === times && this.releaseInvoked === times
+  }
+
+  _handleProtocolError (message) {
+    this.protocolErrorsHandled++
+    this.seenProtocolErrors.push(message)
+  }
+
+  withProtocolVersion (version) {
+    this.protocolVersion = version
+    return this
+  }
+
+  withCreationTimestamp (value) {
+    this.creationTimestamp = value
+    return this
+  }
+
+  withRequestRoutingInformationMock (requestRoutingInformationMock) {
+    this._requestRoutingInformationMock = requestRoutingInformationMock
+    return this
+  }
+
+  closed () {
+    this._open = false
+    return this
+  }
+}

test/internal/rediscovery.test.js renamed to bolt-connection/test/rediscovery/rediscovery.test.js

@@ -17,10 +17,10 @@
  * limitations under the License.
  */
 
-import { RawRoutingTable } from '../../bolt-connection/lib/bolt'
-import Rediscovery from '../../bolt-connection/lib/rediscovery'
-import RoutingTable from '../../bolt-connection/lib/rediscovery/routing-table'
-import FakeConnection from './fake-connection'
+import { RawRoutingTable } from '../../src/bolt'
+import Rediscovery from '../../src/rediscovery'
+import RoutingTable from '../../src/rediscovery/routing-table'
+import FakeConnection from '../fake-connection'
 import lolex from 'lolex'
 import { newError, error, int, internal } from 'neo4j-driver-core'
 
@@ -106,7 +106,6 @@ describe('#unit Rediscovery', () => {
     const requestParams = connection.seenRequestRoutingInformation[0]
     expect(requestParams.routingContext).toEqual(routingContext)
     expect(requestParams.databaseName).toEqual(database)
-    expect(requestParams.initialAddress).toEqual(initialAddress)
     expect(requestParams.sessionContext).toEqual({
       bookmark: session._lastBookmark,
       mode: session._mode,

test/internal/fake-connection.js

@@ -18,7 +18,6 @@
  */
 
 import Connection from '../../bolt-connection/lib/connection/connection'
-import { textChangeRangeIsUnchanged } from 'typescript'
 import {
   ServerVersion,
   VERSION_3_4_0,