refactors and simplifies password change epic

Author: daveajrussell

src/shared/modules/connections/connectionsDuck.test.ts

@@ -28,8 +28,9 @@ import {
   DONE as DISCOVERY_DONE,
   updateDiscoveryConnection
 } from 'shared/modules/discovery/discoveryDuck'
-import forceResetPasswordQueryHelper from './forceResetPasswordQueryHelper'
-import { buildTxFunctionByMode } from 'services/bolt/boltHelpers'
+import forceResetPasswordQueryHelper, {
+  MultiDatabaseNotSupportedError
+} from './forceResetPasswordQueryHelper'
 
 jest.mock('services/bolt/bolt', () => {
   return {
@@ -39,14 +40,6 @@ jest.mock('services/bolt/bolt', () => {
   }
 })
 
-jest.mock('services/bolt/boltHelpers', () => {
-  const orig = jest.requireActual('services/bolt/boltHelpers')
-  return {
-    ...orig,
-    buildTxFunctionByMode: jest.fn()
-  }
-})
-
 describe('connections reducer', () => {
   test('handles connections.SET_ACTIVE', () => {
     const initialState: any = {
@@ -505,10 +498,12 @@ describe('handleForcePasswordChangeEpic', () => {
   )
 
   const mockSessionClose = jest.fn()
+  const mockSessionExecuteWrite = jest.fn()
 
   const mockDriver = {
     session: jest.fn().mockReturnValue({
-      close: mockSessionClose
+      close: mockSessionClose,
+      executeWrite: mockSessionExecuteWrite
     }),
     close: jest.fn().mockReturnValue(true)
   }
@@ -576,9 +571,7 @@ describe('handleForcePasswordChangeEpic', () => {
 
   test('handleForcePasswordChangeEpic resolves when successfully executing cypher query', () => {
     // Given
-    ;(buildTxFunctionByMode as jest.Mock).mockReturnValue(() =>
-      Promise.resolve()
-    )
+    mockSessionExecuteWrite.mockResolvedValue(true)
 
     const p = new Promise<void>((resolve, reject) => {
       bus.take($$responseChannel, currentAction => {
@@ -632,11 +625,11 @@ describe('handleForcePasswordChangeEpic', () => {
 
   test('handleForcePasswordChangeEpic resolves with an error if cypher query fails', () => {
     // Given
-    ;(buildTxFunctionByMode as jest.Mock)
-      .mockReturnValueOnce(() =>
-        Promise.reject(new Error('A password must be at least 8 characters.'))
+    mockSessionExecuteWrite
+      .mockRejectedValueOnce(
+        new Error('A password must be at least 8 characters.')
       )
-      .mockReturnValue(() => Promise.resolve())
+      .mockResolvedValue(true)
 
     const p = new Promise<void>((resolve, reject) => {
       bus.take($$responseChannel, currentAction => {
@@ -682,11 +675,9 @@ describe('handleForcePasswordChangeEpic', () => {
 
   test('handleForcePasswordChangeEpic resolves when successfully falling back to dbms function call', () => {
     // Given
-    ;(buildTxFunctionByMode as jest.Mock)
-      .mockReturnValueOnce(() =>
-        Promise.reject(new Error("Invalid input 'A': expected <init>"))
-      )
-      .mockReturnValue(() => Promise.resolve())
+    mockSessionExecuteWrite
+      .mockRejectedValueOnce(new MultiDatabaseNotSupportedError())
+      .mockResolvedValue(true)
 
     const p = new Promise<void>((resolve, reject) => {
       bus.take($$responseChannel, currentAction => {
@@ -740,13 +731,9 @@ describe('handleForcePasswordChangeEpic', () => {
 
   test('handleForcePasswordChangeEpic resolves with an error if dbms function call fails', () => {
     // Given
-    ;(buildTxFunctionByMode as jest.Mock)
-      .mockReturnValueOnce(() =>
-        Promise.reject(new Error("Invalid input 'A': expected <init>"))
-      )
-      .mockReturnValue(() =>
-        Promise.reject(new Error('A password must be at least 8 characters.'))
-      )
+    mockSessionExecuteWrite
+      .mockRejectedValueOnce(new MultiDatabaseNotSupportedError())
+      .mockRejectedValue(new Error('A password must be at least 8 characters.'))
 
     const p = new Promise<void>((resolve, reject) => {
       bus.take($$responseChannel, currentAction => {

src/shared/modules/connections/connectionsDuck.ts

@@ -40,7 +40,9 @@ import { NEO4J_CLOUD_DOMAINS } from 'shared/modules/settings/settingsDuck'
 import { isCloudHost } from 'shared/services/utils'
 import { fetchMetaData } from '../dbMeta/dbMetaDuck'
 import { isError } from 'shared/utils/typeguards'
-import forceResetPasswordQueryHelper from './forceResetPasswordQueryHelper'
+import forceResetPasswordQueryHelper, {
+  MultiDatabaseNotSupportedError
+} from './forceResetPasswordQueryHelper'
 
 export const NAME = 'connections'
 export const SET_ACTIVE = 'connections/SET_ACTIVE'
@@ -949,6 +951,22 @@ export const handleForcePasswordChangeEpic = (some$: any) =>
         if (!action.$$responseChannel) return Rx.Observable.of(null)
 
         return new Promise(resolve => {
+          const resolveResponse = (error?: Error) => {
+            resolve({
+              type: action.$$responseChannel,
+              success: error === undefined,
+              ...(error === undefined
+                ? {
+                    result: {
+                      meta: action.host
+                    }
+                  }
+                : {
+                    error
+                  })
+            })
+          }
+
           bolt
             .directConnect(
               action,
@@ -958,64 +976,28 @@ export const handleForcePasswordChangeEpic = (some$: any) =>
             )
             .then(async driver => {
               try {
-                const res = await forceResetPasswordQueryHelper
+                const result = await forceResetPasswordQueryHelper
                   .executeAlterCurrentUserQuery(driver, action)
-                  .then((res: any) => {
-                    resolve({
-                      type: action.$$responseChannel,
-                      success: true,
-                      result: {
-                        ...res,
-                        meta: action.host
-                      }
-                    })
-                  })
-                  .catch(e => {
-                    return e
-                  })
+                  .then(() => resolveResponse())
+                  .catch(error => error)
 
-                if (isError(res)) {
-                  if (
-                    /(Invalid input 'A': expected <init>)/.test(res.message)
-                  ) {
+                if (isError(result)) {
+                  if (result instanceof MultiDatabaseNotSupportedError) {
+                    // If we get a multi database not supported error, fall back to the legacy function
                     await forceResetPasswordQueryHelper
                       .executeCallChangePasswordQuery(driver, action)
-                      .then((res: any) => {
-                        resolve({
-                          type: action.$$responseChannel,
-                          success: true,
-                          result: {
-                            ...res,
-                            meta: action.host
-                          }
-                        })
-                      })
-                      .catch(e =>
-                        resolve({
-                          type: action.$$responseChannel,
-                          success: false,
-                          error: e
-                        })
-                      )
+                      .then(() => resolveResponse())
+                      .catch(resolveResponse)
                   } else {
-                    resolve({
-                      type: action.$$responseChannel,
-                      success: false,
-                      error: res
-                    })
+                    // Otherwise, return the error for the UI to handle e.g. invalid password
+                    resolveResponse(result)
                   }
                 }
               } finally {
                 driver.close()
               }
             })
-            .catch(e =>
-              resolve({
-                type: action.$$responseChannel,
-                success: false,
-                error: e
-              })
-            )
+            .catch(resolveResponse)
         })
       }
     )

src/shared/modules/connections/forceResetPasswordQueryHelper.ts

@@ -3,7 +3,12 @@ import { Driver } from 'neo4j-driver'
 import { userActionTxMetadata } from 'services/bolt/txMetadata'
 import { Connection } from './connectionsDuck'
 import { SYSTEM_DB } from '../dbMeta/dbMetaDuck'
-import { buildTxFunctionByMode } from 'services/bolt/boltHelpers'
+import { isError } from 'shared/utils/typeguards'
+
+const MULTIDATABASE_NOT_SUPPORTED_ERROR_MESSAGE =
+  'Driver is connected to the database that does not support multiple databases.'
+
+export class MultiDatabaseNotSupportedError extends Error {}
 
 export default {
   executePasswordResetQuery: async (
@@ -20,22 +25,21 @@ export default {
       ...useDb
     })
 
-    const txFn = buildTxFunctionByMode(session)
-
-    txFn &&
-      (await txFn(
-        async (tx: { run: (input: string, parameters: unknown) => unknown }) =>
-          await tx.run(action.query, action.parameters),
+    try {
+      await session.executeWrite(
+        tx => tx.run(action.query, action.parameters),
         {
           metadata
         }
       )
-        .catch(e => {
-          throw e
-        })
-        .finally(() => {
-          session.close()
-        }))
+    } catch (e) {
+      throw isError(e) &&
+        e.message.startsWith(MULTIDATABASE_NOT_SUPPORTED_ERROR_MESSAGE)
+        ? new MultiDatabaseNotSupportedError(e.message)
+        : e
+    } finally {
+      session.close()
+    }
   },
   /**
    * Executes a query to change the user's password using Cypher available