Add a couple of tests

Author: ali-ince

src/internal/connection-delegate.js

@@ -27,8 +27,10 @@ export default class DelegateConnection extends Connection {
   constructor (delegate, errorHandler) {
     super(errorHandler)
 
-    this._originalErrorHandler = delegate._errorHandler
-    delegate._errorHandler = this._errorHandler
+    if (errorHandler) {
+      this._originalErrorHandler = delegate._errorHandler
+      delegate._errorHandler = this._errorHandler
+    }
 
     this._delegate = delegate
   }
@@ -45,12 +47,8 @@ export default class DelegateConnection extends Connection {
     this._delegate.databaseId = value
   }
 
-  isOpen () {
-    return this._delegate.isOpen()
-  }
-
-  protocol () {
-    return this._delegate.protocol()
+  get server () {
+    return this._delegate.server
   }
 
   get address () {
@@ -65,8 +63,12 @@ export default class DelegateConnection extends Connection {
     this._delegate.version = value
   }
 
-  get server () {
-    return this._delegate.server
+  isOpen () {
+    return this._delegate.isOpen()
+  }
+
+  protocol () {
+    return this._delegate.protocol()
   }
 
   connect (userAgent, authToken) {
@@ -86,7 +88,10 @@ export default class DelegateConnection extends Connection {
   }
 
   _release () {
-    this._delegate._errorHandler = this._originalErrorHandler
+    if (this._originalErrorHandler) {
+      this._delegate._errorHandler = this._originalErrorHandler
+    }
+
     this._delegate._release()
   }
 }

src/internal/connection-provider-direct.js

@@ -18,6 +18,7 @@
  */
 
 import PooledConnectionProvider from './connection-provider-pooled'
+import DelegateConnection from './connection-delegate'
 
 export default class DirectConnectionProvider extends PooledConnectionProvider {
   constructor ({ id, config, log, address, userAgent, authToken }) {
@@ -27,6 +28,8 @@ export default class DirectConnectionProvider extends PooledConnectionProvider {
   }
 
   acquireConnection (accessMode, database) {
-    return this._connectionPool.acquire(this._address)
+    return this._connectionPool
+      .acquire(this._address)
+      .then(connection => new DelegateConnection(connection, null))
   }
 }

test/internal/connection-delegate.test.js

@@ -0,0 +1,189 @@
+/**
+ * Copyright (c) 2002-2019 "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 DelegateConnection from '../../src/internal/connection-delegate'
+import Connection from '../../src/internal/connection'
+import BoltProtocol from '../../src/internal/bolt-protocol-v1'
+import BoltAddress from '../../src/internal/server-address'
+import ConnectionErrorHandler from '../../src/internal/connection-error-handler'
+
+describe('#unit DelegateConnection', () => {
+  it('should delegate get id', () => {
+    const delegate = new Connection(null)
+    const spy = spyOnProperty(delegate, 'id', 'get').and.returnValue(5)
+    const connection = new DelegateConnection(delegate, null)
+
+    expect(connection.id).toBe(5)
+    expect(spy).toHaveBeenCalledTimes(1)
+  })
+
+  it('should delegate get databaseId', () => {
+    const delegate = new Connection(null)
+    const spy = spyOnProperty(delegate, 'databaseId', 'get').and.returnValue(
+      '123-456'
+    )
+    const connection = new DelegateConnection(delegate, null)
+
+    expect(connection.databaseId).toBe('123-456')
+    expect(spy).toHaveBeenCalledTimes(1)
+  })
+
+  it('should delegate set databaseId', () => {
+    const delegate = new Connection(null)
+    const spy = spyOnProperty(delegate, 'databaseId', 'set')
+    const connection = new DelegateConnection(delegate, null)
+
+    connection.databaseId = '345-678'
+
+    expect(spy).toHaveBeenCalledTimes(1)
+  })
+
+  it('should delegate get server', () => {
+    const server = {
+      address: BoltAddress.fromUrl('bolt://127.0.0.1:8798'),
+      version: 'Neo4j/3.5.6'
+    }
+    const delegate = new Connection(null)
+    const spy = spyOnProperty(delegate, 'server', 'get').and.returnValue(server)
+    const connection = new DelegateConnection(delegate, null)
+
+    expect(connection.server).toBe(server)
+    expect(spy).toHaveBeenCalledTimes(1)
+  })
+
+  it('should delegate get address', () => {
+    const address = BoltAddress.fromUrl('bolt://127.0.0.1:8080')
+    const delegate = new Connection(null)
+    const spy = spyOnProperty(delegate, 'address', 'get').and.returnValue(
+      address
+    )
+    const connection = new DelegateConnection(delegate, null)
+
+    expect(connection.address).toBe(address)
+    expect(spy).toHaveBeenCalledTimes(1)
+  })
+
+  it('should delegate get version', () => {
+    const version = 'Neo4j/3.5.6'
+    const delegate = new Connection(null)
+    const spy = spyOnProperty(delegate, 'version', 'get').and.returnValue(
+      version
+    )
+    const connection = new DelegateConnection(delegate, null)
+
+    expect(connection.version).toBe(version)
+    expect(spy).toHaveBeenCalledTimes(1)
+  })
+
+  it('should delegate set version', () => {
+    const delegate = new Connection(null)
+    const spy = spyOnProperty(delegate, 'version', 'set')
+    const connection = new DelegateConnection(delegate, null)
+
+    connection.version = 'Neo4j/3.4.9'
+
+    expect(spy).toHaveBeenCalledTimes(1)
+  })
+
+  it('should delegate isOpen', () => {
+    const delegate = new Connection(null)
+    const spy = spyOn(delegate, 'isOpen').and.returnValue(true)
+    const connection = new DelegateConnection(delegate, null)
+
+    expect(connection.isOpen()).toBeTruthy()
+    expect(spy).toHaveBeenCalledTimes(1)
+  })
+
+  it('should delegate protocol', () => {
+    const protocol = new BoltProtocol()
+    const delegate = new Connection(null)
+    const spy = spyOn(delegate, 'protocol').and.returnValue(protocol)
+    const connection = new DelegateConnection(delegate, null)
+
+    expect(connection.protocol()).toBe(protocol)
+    expect(spy).toHaveBeenCalledTimes(1)
+  })
+
+  it('should delegate connect', () => {
+    const delegate = new Connection(null)
+    const spy = spyOn(delegate, 'connect')
+    const connection = new DelegateConnection(delegate, null)
+
+    connection.connect('neo4j/js-driver', {})
+
+    expect(spy).toHaveBeenCalledTimes(1)
+  })
+
+  it('should delegate write', () => {
+    const delegate = new Connection(null)
+    const spy = spyOn(delegate, 'write')
+    const connection = new DelegateConnection(delegate, null)
+
+    connection.write({}, null, true)
+
+    expect(spy).toHaveBeenCalledTimes(1)
+  })
+
+  it('should delegate resetAndFlush', () => {
+    const delegate = new Connection(null)
+    const spy = spyOn(delegate, 'resetAndFlush')
+    const connection = new DelegateConnection(delegate, null)
+
+    connection.resetAndFlush()
+
+    expect(spy).toHaveBeenCalledTimes(1)
+  })
+
+  it('should delegate close', () => {
+    const delegate = new Connection(null)
+    const spy = spyOn(delegate, 'close')
+    const connection = new DelegateConnection(delegate, null)
+
+    connection.close()
+
+    expect(spy).toHaveBeenCalledTimes(1)
+  })
+
+  it('should delegate _release', () => {
+    const delegate = new Connection(null)
+    delegate._release = () => {}
+    const spy = spyOn(delegate, '_release')
+    const connection = new DelegateConnection(delegate, null)
+
+    connection._release()
+
+    expect(spy).toHaveBeenCalledTimes(1)
+  })
+
+  it('should override errorHandler on create and restore on release', () => {
+    const errorHandlerOriginal = new ConnectionErrorHandler('code1')
+    const delegate = new Connection(errorHandlerOriginal)
+    delegate._release = () => {}
+
+    expect(delegate._errorHandler).toBe(errorHandlerOriginal)
+
+    const errorHandlerNew = new ConnectionErrorHandler('code2')
+    const connection = new DelegateConnection(delegate, errorHandlerNew)
+
+    expect(delegate._errorHandler).toBe(errorHandlerNew)
+
+    connection._release()
+
+    expect(delegate._errorHandler).toBe(errorHandlerOriginal)
+  })
+})

test/internal/connection-provider-direct.test.js

@@ -23,22 +23,31 @@ import Pool from '../../src/internal/pool'
 import ServerAddress from '../../src/internal/server-address'
 import Connection from '../../src/internal/connection'
 import Logger from '../../src/internal/logger'
+import DelegateConnection from '../../src/internal/connection-delegate'
 
 describe('#unit DirectConnectionProvider', () => {
   it('acquires connection from the pool', done => {
     const address = ServerAddress.fromUrl('localhost:123')
     const pool = newPool()
     const connectionProvider = newDirectConnectionProvider(address, pool)
 
-    connectionProvider.acquireConnection(READ).then(connection => {
+    connectionProvider.acquireConnection(READ, '').then(connection => {
       expect(connection).toBeDefined()
       expect(connection.address).toEqual(address)
-      expect(connection.release).toBeDefined()
       expect(pool.has(address)).toBeTruthy()
 
       done()
     })
   })
+
+  it('acquires connection and returns a DelegateConnection', async () => {
+    const address = ServerAddress.fromUrl('localhost:123')
+    const pool = newPool()
+    const connectionProvider = newDirectConnectionProvider(address, pool)
+
+    const conn = await connectionProvider.acquireConnection(READ, '')
+    expect(conn instanceof DelegateConnection).toBeTruthy()
+  })
 })
 
 function newDirectConnectionProvider (address, pool) {

test/internal/connection-provider-routing.test.js

@@ -28,6 +28,7 @@ import ServerAddress from '../../src/internal/server-address'
 import RoutingConnectionProvider from '../../src/internal/connection-provider-routing'
 import { VERSION_IN_DEV } from '../../src/internal/server-version'
 import Connection from '../../src/internal/connection'
+import DelegateConnection from '../../src/internal/connection-delegate'
 
 describe('#unit RoutingConnectionProvider', () => {
   let originalTimeout
@@ -169,6 +170,23 @@ describe('#unit RoutingConnectionProvider', () => {
     )
   })
 
+  it('acquires connection and returns a DelegateConnection', async () => {
+    const pool = newPool()
+    const connectionProvider = newRoutingConnectionProvider(
+      '',
+      [server1, server2],
+      [server3, server4],
+      [server5, server6],
+      pool
+    )
+
+    const conn1 = await connectionProvider.acquireConnection(READ, '')
+    expect(conn1 instanceof DelegateConnection).toBeTruthy()
+
+    const conn2 = await connectionProvider.acquireConnection(WRITE, '')
+    expect(conn2 instanceof DelegateConnection).toBeTruthy()
+  })
+
   it('acquires read connection with up-to-date routing table', done => {
     const pool = newPool()
     const connectionProvider = newRoutingConnectionProvider(