Sync Deno and adapt testkit-backend

Author: bigmontz

packages/neo4j-driver-deno/lib/bolt-connection/connection-provider/connection-provider-direct.js

@@ -50,8 +50,8 @@ export default class DirectConnectionProvider extends PooledConnectionProvider {
   async acquireConnection ({ accessMode, database, bookmarks, auth, forceReAuth } = {}) {
     const databaseSpecificErrorHandler = ConnectionErrorHandler.create({
       errorCode: SERVICE_UNAVAILABLE,
-      handleAuthorizationExpired: (error, address, conn) =>
-        this._handleAuthorizationExpired(error, address, conn, database)
+      handleSecurityError: (error, address, conn) =>
+        this._handleSecurityError(error, address, conn, database)
     })
 
     const connection = await this._connectionPool.acquire({ auth, forceReAuth }, this._address)
@@ -68,12 +68,12 @@ export default class DirectConnectionProvider extends PooledConnectionProvider {
     return new DelegateConnection(connection, databaseSpecificErrorHandler)
   }
 
-  _handleAuthorizationExpired (error, address, connection, database) {
+  _handleSecurityError (error, address, connection, database) {
     this._log.warn(
       `Direct driver ${this._id} will close connection to ${address} for database '${database}' because of an error ${error.code} '${error.message}'`
     )
 
-    return super._handleAuthorizationExpired(error, address, connection)
+    return super._handleSecurityError(error, address, connection)
   }
 
   async _hasProtocolVersion (versionPredicate) {

packages/neo4j-driver-deno/lib/bolt-connection/connection-provider/connection-provider-pooled.js

@@ -223,7 +223,7 @@ export default class PooledConnectionProvider extends ConnectionProvider {
     conn._updateCurrentObserver()
   }
 
-  _handleAuthorizationExpired (error, address, connection) {
+  _handleSecurityError (error, address, connection) {
     const handled = this._authenticationProvider.handleError({ connection, code: error.code })
 
     if (handled) {

packages/neo4j-driver-deno/lib/bolt-connection/connection-provider/connection-provider-routing.js

@@ -116,12 +116,12 @@ export default class RoutingConnectionProvider extends PooledConnectionProvider
     return error
   }
 
-  _handleAuthorizationExpired (error, address, connection, database) {
+  _handleSecurityError (error, address, connection, database) {
     this._log.warn(
       `Routing driver ${this._id} will close connections to ${address} for database '${database}' because of an error ${error.code} '${error.message}'`
     )
 
-    return super._handleAuthorizationExpired(error, address, connection, database)
+    return super._handleSecurityError(error, address, connection, database)
   }
 
   _handleWriteFailure (error, address, database) {
@@ -150,7 +150,7 @@ export default class RoutingConnectionProvider extends PooledConnectionProvider
       (error, address) => this._handleUnavailability(error, address, context.database),
       (error, address) => this._handleWriteFailure(error, address, context.database),
       (error, address, conn) =>
-        this._handleAuthorizationExpired(error, address, conn, context.database)
+        this._handleSecurityError(error, address, conn, context.database)
     )
 
     const routingTable = await this._freshRoutingTable({
@@ -584,7 +584,7 @@ export default class RoutingConnectionProvider extends PooledConnectionProvider
 
       const databaseSpecificErrorHandler = ConnectionErrorHandler.create({
         errorCode: SESSION_EXPIRED,
-        handleAuthorizationExpired: (error, address, conn) => this._handleAuthorizationExpired(error, address, conn)
+        handleSecurityError: (error, address, conn) => this._handleSecurityError(error, address, conn)
       })
 
       const delegateConnection = !connection._sticky

packages/neo4j-driver-deno/lib/bolt-connection/connection/connection-error-handler.js

@@ -26,25 +26,25 @@ export default class ConnectionErrorHandler {
     errorCode,
     handleUnavailability,
     handleWriteFailure,
-    handleAuthorizationExpired
+    handleSecurityError
   ) {
     this._errorCode = errorCode
     this._handleUnavailability = handleUnavailability || noOpHandler
     this._handleWriteFailure = handleWriteFailure || noOpHandler
-    this._handleAuthorizationExpired = handleAuthorizationExpired || noOpHandler
+    this._handleSecurityError = handleSecurityError || noOpHandler
   }
 
   static create ({
     errorCode,
     handleUnavailability,
     handleWriteFailure,
-    handleAuthorizationExpired
+    handleSecurityError
   }) {
     return new ConnectionErrorHandler(
       errorCode,
       handleUnavailability,
       handleWriteFailure,
-      handleAuthorizationExpired
+      handleSecurityError
     )
   }
 
@@ -63,8 +63,8 @@ export default class ConnectionErrorHandler {
    * @return {Neo4jError} new error that should be propagated to the user.
    */
   handleAndTransformError (error, address, connection) {
-    if (isAutorizationExpiredError(error)) {
-      return this._handleAuthorizationExpired(error, address, connection)
+    if (isSecurityError(error)) {
+      return this._handleSecurityError(error, address, connection)
     }
     if (isAvailabilityError(error)) {
       return this._handleUnavailability(error, address, connection)
@@ -76,11 +76,10 @@ export default class ConnectionErrorHandler {
   }
 }
 
-function isAutorizationExpiredError (error) {
-  return error && (
-    error.code === 'Neo.ClientError.Security.AuthorizationExpired' ||
-      error.code === 'Neo.ClientError.Security.TokenExpired'
-  )
+function isSecurityError (error) {
+  return error != null &&
+    error.code != null &&
+    error.code.startsWith('Neo.ClientError.Security.')
 }
 
 function isAvailabilityError (error) {

packages/neo4j-driver-deno/lib/core/auth-token-manager.ts

@@ -120,7 +120,7 @@ class AuthTokenManagers {
    * **Warning**: `tokenProvider` must only ever return auth information belonging to the same identity.
    * Switching identities using the `AuthTokenManager` is undefined behavior.
    *
-   * @param param0 - The params
+   * @param {object} param0 - The params
    * @param {function(): Promise<AuthToken>} param0.tokenProvider - Retrieves a new valid auth token.
    * Must only ever return auth information belonging to the same identity.
    * @returns {AuthTokenManager} The basic auth data manager.
@@ -139,8 +139,16 @@ class AuthTokenManagers {
 
 /**
  * Holds the common {@link AuthTokenManagers} used in the Driver
+ *
+ * @experimental Exposed as preview feature.
  */
-export const authTokenManagers: AuthTokenManagers = Object.freeze(new AuthTokenManagers())
+const authTokenManagers: AuthTokenManagers = new AuthTokenManagers()
+
+Object.freeze(authTokenManagers)
+
+export {
+  authTokenManagers
+}
 
 export type {
   AuthTokenManagers

packages/testkit-backend/src/request-handlers-rx.js

@@ -28,7 +28,7 @@ export {
   NewAuthTokenManager,
   AuthTokenManagerClose,
   AuthTokenManagerGetAuthCompleted,
-  AuthTokenManagerOnAuthExpiredCompleted,
+  AuthTokenManagerHandleSecurityExceptionCompleted,
   NewBearerAuthTokenManager,
   BearerAuthTokenProviderCompleted,
   NewBasicAuthTokenManager,

packages/testkit-backend/src/request-handlers.js

@@ -529,15 +529,16 @@ export function NewAuthTokenManager (_, context, _data, wire) {
         wire.writeResponse(responses.AuthTokenManagerGetAuthRequest({ id, authTokenManagerId }))
       }),
       handleSecurityException: (auth, code) => {
-        if ([
-          'Neo.ClientError.Security.Unauthorized',
-          'Neo.ClientError.Security.TokenExpired'
-        ].includes(code)) {
-          const id = context.addAuthTokenManagerOnAuthExpiredRequest()
-          wire.writeResponse(responses.AuthTokenManagerOnAuthExpiredRequest({ id, authTokenManagerId, auth }))
-          return true
-        }
-        return false
+        // The handle security exception should wait for the response
+        // to return the error as handle.
+        // However, testkit doesn't enable sync communication and
+        // the `handleSecurityException` must be sync since the
+        // part of the code which get called depends on it be sync.
+        // Send the message and return true is a naive implementation
+        // for making some of the tests valid.
+        const id = context.addAuthTokenManagerOnAuthExpiredRequest()
+        wire.writeResponse(responses.AuthTokenManagerHandleSecurityExceptionRequest({ id, authTokenManagerId, auth, code }))
+        return true
       }
     }
   })
@@ -556,7 +557,8 @@ export function AuthTokenManagerGetAuthCompleted (_, context, { requestId, auth
   context.removeAuthTokenManagerGetAuthRequest(requestId)
 }
 
-export function AuthTokenManagerOnAuthExpiredCompleted (_, context, { requestId }) {
+export function AuthTokenManagerHandleSecurityExceptionCompleted (_, context, { requestId }) {
+  // See NewAuthTokenManager
   context.removeAuthTokenManagerOnAuthExpiredRequest(requestId)
 }
 

packages/testkit-backend/src/responses.js

@@ -115,8 +115,8 @@ export function AuthorizationToken (data) {
   return response('AuthorizationToken', data)
 }
 
-export function AuthTokenManagerOnAuthExpiredRequest ({ id, authTokenManagerId, auth }) {
-  return response('AuthTokenManagerOnAuthExpiredRequest', { id, authTokenManagerId, auth: AuthorizationToken(auth) })
+export function AuthTokenManagerHandleSecurityExceptionRequest ({ id, authTokenManagerId, auth, code }) {
+  return response('AuthTokenManagerHandleSecurityExceptionRequest', { id, authTokenManagerId, auth: AuthorizationToken(auth), error_code: code })
 }
 
 export function BearerAuthTokenManager ({ id }) {

packages/testkit-backend/src/skipped-tests/common.js

@@ -1,4 +1,4 @@
-import skip, { ifEquals, ifEndsWith, endsWith, ifStartsWith, startsWith, not } from './skip.js'
+import skip, { ifEquals, ifEndsWith, endsWith, ifStartsWith, startsWith, not, or } from './skip.js'
 
 const skippedTests = [
   skip(
@@ -184,6 +184,20 @@ const skippedTests = [
     ifEquals(
       'stub.driver_parameters.test_connection_acquisition_timeout_ms.TestConnectionAcquisitionTimeoutMs.test_does_not_encompass_router_handshake'
     )
+  ),
+  skip(
+    'Backend does not support async AuthTokenManager.handleSecurityException',
+    ifStartsWith('stub.authorization.test_auth_token_manager.TestAuthTokenManager')
+      .and(
+        or(
+          endsWith('test_error_on_pull_using_session_run'),
+          endsWith('test_error_on_begin_using_tx_run'),
+          endsWith('test_error_on_run_using_tx_run'),
+          endsWith('test_error_on_pull_using_tx_run'),
+          endsWith('test_error_on_commit_using_tx_run'),
+          endsWith('test_error_on_rollback_using_tx_run')
+        )
+      )
   )
 ]