Add unit tests

Author: bigmontz

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

@@ -47,7 +47,6 @@ const DATABASE_NOT_FOUND_CODE = 'Neo.ClientError.Database.DatabaseNotFound'
 const INVALID_BOOKMARK_CODE = 'Neo.ClientError.Transaction.InvalidBookmark'
 const INVALID_BOOKMARK_MIXTURE_CODE = 
   'Neo.ClientError.Transaction.InvalidBookmarkMixture'
-const FORBIDEN_CODE = 'Neo.ClientError.Security.Forbidden'
 const AUTHORIZATION_EXPIRED_CODE = 
   'Neo.ClientError.Security.AuthorizationExpired'
 
@@ -460,7 +459,7 @@ export default class RoutingConnectionProvider extends PooledConnectionProvider
               impersonatedUser
             )
           } catch (error) {
-            return this._handleRediscoveryError(error)
+            return this._handleRediscoveryError(error, currentRouter)
           } finally {
             session.close()
           }
@@ -503,11 +502,11 @@ export default class RoutingConnectionProvider extends PooledConnectionProvider
         impersonatedUser
       })
     } catch (error) {
-      return this._handleRediscoveryError(error)
+      return this._handleRediscoveryError(error, routerAddress)
     }
   }
 
-  _handleRediscoveryError(error) {
+  _handleRediscoveryError(error, routerAddress) {
     if (_isFailFastError(error) || _isFailFastSecurityError(error)) {
       throw error
     } else if (error.code === PROCEDURE_NOT_FOUND_CODE) {
@@ -661,7 +660,6 @@ class RoutingTableRegistry {
 function _isFailFastError (error) {
   return [
     DATABASE_NOT_FOUND_CODE,
-    FORBIDEN_CODE,
     INVALID_BOOKMARK_CODE,
     INVALID_BOOKMARK_MIXTURE_CODE,
   ].includes(error.code)

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

@@ -1657,6 +1657,86 @@ describe('#unit RoutingConnectionProvider', () => {
       })
   }, 10000)
 
+  describe('when rediscovery.lookupRoutingTableOnRouter fails', () => {
+    describe.each([
+      'Neo.ClientError.Database.DatabaseNotFound',
+      'Neo.ClientError.Transaction.InvalidBookmark',
+      'Neo.ClientError.Transaction.InvalidBookmarkMixture',
+      'Neo.ClientError.Security.Forbidden',
+      'Neo.ClientError.Security.IWontTellYou'
+    ])('with "%s"', errorCode => {
+      it('should fail without change the error ', async () => {
+        const error = newError('something wrong', errorCode)
+        const connectionProvider = newRoutingConnectionProviderWithFakeRediscovery(
+          new FakeRediscovery(null, error),
+          newPool()
+        )
+
+        let completed = false
+        try {
+          await connectionProvider.acquireConnection({ accessMode: READ })
+          completed = true
+        } catch (capturedError) {
+          expect(capturedError).toBe(error)
+        }
+
+        expect(completed).toBe(false)
+      })
+    })
+
+    describe('with "Neo.ClientError.Procedure.ProcedureNotFound"', () => {
+      it('should fail with SERVICE_UNAVAILABLE and a message about do not connect to cause cluster', async () => {
+        const error = newError('something wrong', 'Neo.ClientError.Procedure.ProcedureNotFound')
+        const connectionProvider = newRoutingConnectionProviderWithFakeRediscovery(
+          new FakeRediscovery(null, error),
+          newPool()
+        )
+
+        let completed = false
+        try {
+          await connectionProvider.acquireConnection({ accessMode: READ })
+          completed = true
+        } catch (capturedError) {
+          expect(capturedError.code).toBe(SERVICE_UNAVAILABLE)
+          expect(capturedError.message).toBe(
+            'Server at server-non-existing-seed-router:7687 can\'t '
+             + 'perform routing. Make sure you are connecting to a causal cluster'
+          )
+        }
+
+        expect(completed).toBe(false)
+      })
+    })
+
+    describe.each([
+      'Neo.ClientError.Security.AuthorizationExpired',
+      'Neo.ClientError.MadeUp.Error'
+    ])('with "%s"', errorCode => {
+      it('should fail with SERVICE_UNAVAILABLE and message about no routing servers available ', async () => {
+        const error = newError('something wrong', errorCode)
+        const connectionProvider = newRoutingConnectionProviderWithFakeRediscovery(
+          new FakeRediscovery(null, error),
+          newPool()
+        )
+
+        let completed = false
+        try {
+          await connectionProvider.acquireConnection({ accessMode: READ })
+          completed = true
+        } catch (capturedError) {
+          expect(capturedError.code).toBe(SERVICE_UNAVAILABLE)
+          expect(capturedError.message).toEqual(expect.stringContaining(
+            'Could not perform discovery. ' +
+            'No routing servers available. Known routing table: '
+          ))
+        }
+
+        expect(completed).toBe(false)
+      })
+
+    })
+  })
+
   describe('multi-database', () => {
     it.each(usersDataSet)('should acquire read connection from correct routing table [user=%s]', async (user) => {
       const pool = newPool()
@@ -2491,13 +2571,31 @@ function newRoutingConnectionProvider (
   )
 }
 
+function newRoutingConnectionProviderWithFakeRediscovery (
+  fakeRediscovery,
+  pool = null,
+  routerToRoutingTable = { null: {} }
+) {
+  const seedRouter = ServerAddress.fromUrl('server-non-existing-seed-router')
+  return newRoutingConnectionProviderWithSeedRouter(
+    seedRouter,
+    [seedRouter],
+    [],
+    routerToRoutingTable,
+    pool,
+    null,
+    fakeRediscovery
+  )
+}
+
 function newRoutingConnectionProviderWithSeedRouter (
   seedRouter,
   seedRouterResolved,
   routingTables,
   routerToRoutingTable = { null: {} },
   connectionPool = null,
-  routingTablePurgeDelay = null
+  routingTablePurgeDelay = null,
+  fakeRediscovery = null
 ) {
   const pool = connectionPool || newPool()
   const connectionProvider = new RoutingConnectionProvider({
@@ -2513,7 +2611,8 @@ function newRoutingConnectionProviderWithSeedRouter (
   routingTables.forEach(r => {
     connectionProvider._routingTableRegistry.register(r)
   })
-  connectionProvider._rediscovery = new FakeRediscovery(routerToRoutingTable)
+  connectionProvider._rediscovery =
+    fakeRediscovery || new FakeRediscovery(routerToRoutingTable)
   connectionProvider._hostNameResolver = new FakeDnsResolver(seedRouterResolved)
   connectionProvider._useSeedRouter = routingTables.every(
     r => r.expirationTime !== Integer.ZERO
@@ -2630,11 +2729,15 @@ class FakeConnection extends Connection {
 }
 
 class FakeRediscovery {
-  constructor (routerToRoutingTable) {
+  constructor (routerToRoutingTable, error) {
     this._routerToRoutingTable = routerToRoutingTable
+    this._error = error
   }
 
   lookupRoutingTableOnRouter (ignored, database, router, user) {
+    if (this._error) {
+      return Promise.reject(this._error)
+    }
     const table = this._routerToRoutingTable[database || null]
     if (table) {
       let routingTables = table[router.asKey()]