Add tests to the DirectConnectionProvider pool configuration

Author: bigmontz

packages/bolt-connection/src/connection-provider/connection-provider-direct.js

@@ -33,8 +33,8 @@ const {
 const { SERVICE_UNAVAILABLE } = error
 
 export default class DirectConnectionProvider extends PooledConnectionProvider {
-  constructor ({ id, config, log, address, userAgent, authTokenProvider }) {
-    super({ id, config, log, userAgent, authTokenProvider })
+  constructor ({ id, config, log, address, userAgent, authTokenProvider, newPool }) {
+    super({ id, config, log, userAgent, authTokenProvider, newPool })
 
     this._address = address
   }

packages/bolt-connection/test/connection-provider/connection-provider-direct.test.js

@@ -21,6 +21,7 @@ import DirectConnectionProvider from '../../src/connection-provider/connection-p
 import { Pool } from '../../src/pool'
 import { Connection, DelegateConnection } from '../../src/connection'
 import { internal, newError, ServerInfo } from 'neo4j-driver-core'
+import AuthenticationProvider from '../../src/connection-provider/authentication-provider'
 
 const {
   serverAddress: { ServerAddress },
@@ -376,6 +377,236 @@ describe('.verifyConnectivityAndGetServerInfo()', () => {
       }
     })
   })
+
+  describe('constructor', () => {
+    describe('newPool', () => {
+      const server0 = ServerAddress.fromUrl('localhost:123')
+      const server01 = ServerAddress.fromUrl('localhost:1235')
+
+      describe('param.create', () => {
+        it('should create connection', async () => {
+          const { create, createChannelConnectionHook, provider } = setup()
+
+          const connection = await create({}, server0, undefined)
+
+          expect(createChannelConnectionHook).toHaveBeenCalledWith(server0)
+          expect(provider._openConnections[connection.id]).toBe(connection)
+          await expect(createChannelConnectionHook.mock.results[0].value).resolves.toBe(connection)
+        })
+
+        it('should register the release function into the connection', async () => {
+          const { create } = setup()
+          const releaseResult = { property: 'some property' }
+          const release = jest.fn(() => releaseResult)
+
+          const connection = await create({}, server0, release)
+
+          const released = connection._release()
+
+          expect(released).toBe(releaseResult)
+          expect(release).toHaveBeenCalledWith(server0, connection)
+        })
+
+        it.each([
+          null,
+          undefined,
+          { scheme: 'bearer', credentials: 'token01' }
+        ])('should authenticate connection (auth = %o)', async (auth) => {
+          const { create, authenticationProviderHook } = setup()
+
+          const connection = await create({ auth }, server0)
+
+          expect(authenticationProviderHook.authenticate).toHaveBeenCalledWith({
+            connection,
+            auth
+          })
+        })
+
+        it('should handle create connection failures', async () => {
+          const error = newError('some error')
+          const createConnection = jest.fn(() => Promise.reject(error))
+          const { create, authenticationProviderHook, provider } = setup({ createConnection })
+          const openConnections = { ...provider._openConnections }
+
+          await expect(create({}, server0)).rejects.toThrow(error)
+
+          expect(authenticationProviderHook.authenticate).not.toHaveBeenCalled()
+          expect(provider._openConnections).toEqual(openConnections)
+        })
+
+        it.each([
+          null,
+          undefined,
+          { scheme: 'bearer', credentials: 'token01' }
+        ])('should handle authentication failures (auth = %o)', async (auth) => {
+          const error = newError('some error')
+          const authenticationProvider = jest.fn(() => Promise.reject(error))
+          const { create, authenticationProviderHook, createChannelConnectionHook, provider } = setup({ authenticationProvider })
+          const openConnections = { ...provider._openConnections }
+
+          await expect(create({ auth }, server0)).rejects.toThrow(error)
+
+          const connection = await createChannelConnectionHook.mock.results[0].value
+          expect(authenticationProviderHook.authenticate).toHaveBeenCalledWith({ auth, connection })
+          expect(provider._openConnections).toEqual(openConnections)
+          expect(connection._closed).toBe(true)
+        })
+      })
+
+      describe('param.destroy', () => {
+        it('should close connection and unregister it', async () => {
+          const { create, destroy, provider } = setup()
+          const openConnections = { ...provider._openConnections }
+          const connection = await create({}, server0, undefined)
+
+          await destroy(connection)
+
+          expect(connection._closed).toBe(true)
+          expect(provider._openConnections).toEqual(openConnections)
+        })
+      })
+
+      describe('param.validateOnAcquire', () => {
+        it.each([
+          null,
+          undefined,
+          { scheme: 'bearer', credentials: 'token01' }
+        ])('should return true when connection is open and within the lifetime and authentication succeed (auth=%o)', async (auth) => {
+          const connection = new FakeConnection(server0)
+          connection.creationTimestamp = Date.now()
+
+          const { validateOnAcquire, authenticationProviderHook } = setup()
+
+          await expect(validateOnAcquire({ auth }, connection)).resolves.toBe(true)
+
+          expect(authenticationProviderHook.authenticate).toHaveBeenCalledWith({
+            connection, auth
+          })
+        })
+
+        it.each([
+          null,
+          undefined,
+          { scheme: 'bearer', credentials: 'token01' }
+        ])('should return true when connection is open and within the lifetime and authentication fails (auth=%o)', async (auth) => {
+          const connection = new FakeConnection(server0)
+          const error = newError('failed')
+          const authenticationProvider = jest.fn(() => Promise.reject(error))
+          connection.creationTimestamp = Date.now()
+
+          const { validateOnAcquire, authenticationProviderHook, log } = setup({ authenticationProvider })
+
+          await expect(validateOnAcquire({ auth }, connection)).resolves.toBe(false)
+
+          expect(authenticationProviderHook.authenticate).toHaveBeenCalledWith({
+            connection, auth
+          })
+
+          expect(log.debug).toHaveBeenCalledWith(
+            `The connection ${connection.id} is not valid because of an error ${error.code} '${error.message}'`
+          )
+        })
+        it('should return false when connection is closed and within the lifetime', async () => {
+          const connection = new FakeConnection(server0)
+          connection.creationTimestamp = Date.now()
+          await connection.close()
+
+          const { validateOnAcquire, authenticationProviderHook } = setup()
+
+          await expect(validateOnAcquire({}, connection)).resolves.toBe(false)
+          expect(authenticationProviderHook.authenticate).not.toHaveBeenCalled()
+        })
+
+        it('should return false when connection is open and out of the lifetime', async () => {
+          const connection = new FakeConnection(server0)
+          connection.creationTimestamp = Date.now() - 4000
+
+          const { validateOnAcquire, authenticationProviderHook } = setup({ maxConnectionLifetime: 3000 })
+
+          await expect(validateOnAcquire({}, connection)).resolves.toBe(false)
+          expect(authenticationProviderHook.authenticate).not.toHaveBeenCalled()
+        })
+
+        it('should return false when connection is closed and out of the lifetime', async () => {
+          const connection = new FakeConnection(server0)
+          await connection.close()
+          connection.creationTimestamp = Date.now() - 4000
+
+          const { validateOnAcquire, authenticationProviderHook } = setup({ maxConnectionLifetime: 3000 })
+
+          await expect(validateOnAcquire({}, connection)).resolves.toBe(false)
+          expect(authenticationProviderHook.authenticate).not.toHaveBeenCalled()
+        })
+      })
+
+      describe('param.validateOnRelease', () => {
+        it('should return true when connection is open and within the lifetime', () => {
+          const connection = new FakeConnection(server0)
+          connection.creationTimestamp = Date.now()
+
+          const { validateOnRelease } = setup()
+
+          expect(validateOnRelease(connection)).toBe(true)
+        })
+
+        it('should return false when connection is closed and within the lifetime', async () => {
+          const connection = new FakeConnection(server0)
+          connection.creationTimestamp = Date.now()
+          await connection.close()
+
+          const { validateOnRelease } = setup()
+
+          expect(validateOnRelease(connection)).toBe(false)
+        })
+
+        it('should return false when connection is open and out of the lifetime', () => {
+          const connection = new FakeConnection(server0)
+          connection.creationTimestamp = Date.now() - 4000
+
+          const { validateOnRelease } = setup({ maxConnectionLifetime: 3000 })
+
+          expect(validateOnRelease(connection)).toBe(false)
+        })
+
+        it('should return false when connection is closed and out of the lifetime', async () => {
+          const connection = new FakeConnection(server0)
+          await connection.close()
+          connection.creationTimestamp = Date.now() - 4000
+
+          const { validateOnRelease } = setup({ maxConnectionLifetime: 3000 })
+
+          expect(validateOnRelease(connection)).toBe(false)
+        })
+      })
+
+      function setup ({ createConnection, authenticationProvider, maxConnectionLifetime } = {}) {
+        const newPool = jest.fn((...args) => new Pool(...args))
+        const log = new Logger('debug', () => undefined)
+        jest.spyOn(log, 'debug')
+        const createChannelConnectionHook = createConnection || jest.fn(async (address) => new FakeConnection(address))
+        const authenticationProviderHook = new AuthenticationProvider({ })
+        jest.spyOn(authenticationProviderHook, 'authenticate')
+          .mockImplementation(authenticationProvider || jest.fn(({ connection }) => Promise.resolve(connection)))
+        const provider = new DirectConnectionProvider({
+          newPool,
+          config: {
+            maxConnectionLifetime: maxConnectionLifetime || 1000
+          },
+          address: server01,
+          log
+        })
+        provider._createChannelConnection = createChannelConnectionHook
+        provider._authenticationProvider = authenticationProviderHook
+        return {
+          provider,
+          ...newPool.mock.calls[0][0],
+          createChannelConnectionHook,
+          authenticationProviderHook,
+          log
+        }
+      }
+    })
+  })
 })
 
 function newDirectConnectionProvider (address, pool) {
@@ -412,6 +643,12 @@ class FakeConnection extends Connection {
     this._release = jest.fn(() => release(address, this))
     this._server = server
     this._authToken = auth
+    this._closed = false
+    this._id = 1
+  }
+
+  get id () {
+    return this._id
   }
 
   get authToken () {
@@ -431,6 +668,10 @@ class FakeConnection extends Connection {
   }
 
   async close () {
+    this._closed = true
+  }
 
+  isOpen () {
+    return !this._closed
   }
 }