CAMS-461 - Migrate consolidations from ACMS

backend/functions/case-history/case-history.function.ts

@@ -22,7 +22,7 @@ export default async function handler(
       logger,
       request,
     );
-    const caseHistoryController = new CaseHistoryController(applicationContext);
+    const caseHistoryController = new CaseHistoryController();
     const responseBody = await caseHistoryController.handleRequest(applicationContext);
     return toAzureSuccess(responseBody);
   } catch (error) {

backend/functions/host.json

@@ -21,5 +21,10 @@
   "extensionBundle": {
     "id": "Microsoft.Azure.Functions.ExtensionBundle",
     "version": "[4.*, 5.0.0)"
+  },
+  "extensions": {
+    "durableTask": {
+      "hubName": "%MyTaskHub%"
+    }
   }
 }

backend/functions/jest.config.js

@@ -28,6 +28,9 @@ module.exports = {
     'lib/testing/testing-utilities.ts',
     'jest.*config.js',
     'lib/adapters/gateways/okta/HumbleVerifier.ts',
+    'migration/client/',
+    'migration/orchestration/',
+    'migration/loadConsolidations.ts',
   ],
   testMatch: ['**/?(*.)+(spec|test).[jt]s?(x)', '!**/?(*.)+(integration).(spec|test).[jt]s?(x)'],
 };

backend/functions/lib/adapters/gateways/abstract-mssql-client.exception.test.ts

@@ -0,0 +1,177 @@
+import { QueryResults, IDbConfig } from '../types/database';
+import { ConnectionError, MSSQLError, RequestError } from 'mssql';
+import { createMockApplicationContext } from '../../testing/testing-utilities';
+import { AbstractMssqlClient } from './abstract-mssql-client';
+import { ApplicationContext } from '../types/basic';
+
+// Setting default Jest mocks for mssql
+//NOTE: using const here causes these tests to error out with 'Cannot access {var} before initialization
+// eslint-disable-next-line no-var
+var connectionError = new ConnectionError('');
+// eslint-disable-next-line no-var
+var requestError = new RequestError('');
+// eslint-disable-next-line no-var
+var mssqlError = new MSSQLError('');
+
+type AggregateError = Error & {
+  errors?: Error[];
+};
+
+const mockClose = jest.fn();
+const mockConnectionPoolClose = jest.fn();
+const mockQuery = jest.fn();
+const mockRequest = jest.fn().mockImplementation(() => ({
+  input: jest.fn(),
+  query: mockQuery,
+}));
+const mockConnect = jest.fn().mockImplementation(
+  (): Promise<unknown> =>
+    Promise.resolve({
+      request: mockRequest,
+      close: mockClose,
+    }),
+);
+jest.mock('mssql', () => {
+  return {
+    ConnectionError: jest.fn().mockReturnValue(connectionError),
+    RequestError: jest.fn().mockReturnValue(requestError),
+    MSSQLError: jest.fn().mockReturnValue(mssqlError),
+    ConnectionPool: jest.fn().mockImplementation(() => {
+      return {
+        close: mockConnectionPoolClose,
+        connect: mockConnect,
+      };
+    }),
+  };
+});
+
+class MssqlClient extends AbstractMssqlClient {
+  constructor(context: ApplicationContext) {
+    const config = { server: 'foo' } as IDbConfig;
+    super(context, config, 'Exception Tests');
+  }
+}
+
+describe('Tests database client exceptions', () => {
+  let client: MssqlClient;
+  let context: ApplicationContext;
+
+  beforeEach(async () => {
+    jest.resetModules();
+    context = await createMockApplicationContext();
+    client = new MssqlClient(context);
+  });
+
+  test('should handle miscelaneous mssql error exceptions', async () => {
+    const expectedErrorMessage = 'Test request error exception';
+    const requestError = new RequestError(expectedErrorMessage);
+    requestError.name = 'RequestError';
+    requestError.code = '';
+    requestError.message = expectedErrorMessage;
+    mockRequest.mockImplementation(() => {
+      throw requestError;
+    });
+
+    // method under test
+    const queryResult: QueryResults = await client.executeQuery(context, 'SELECT * FROM bar', []);
+
+    expect(mockRequest).toThrow(expectedErrorMessage);
+    expect(queryResult.success).toBeFalsy();
+  });
+
+  test('should handle known mssql MSSQLError exceptions', async () => {
+    const expectedErrorMessage = 'Test MSSQLError exception';
+    const requestError = new RequestError(expectedErrorMessage);
+    requestError.name = 'RequestError';
+    requestError.code = '';
+    requestError.message = expectedErrorMessage;
+    mockRequest.mockImplementation(() => {
+      const mssqlError = new MSSQLError({
+        name: '',
+        message: '',
+      });
+      // not totally sure why I have to set the error in this way to get it to work.
+      mssqlError.name = 'TestMSSQLMessage';
+      mssqlError.message = expectedErrorMessage;
+      mssqlError.code = '1';
+      mssqlError.originalError = { message: 'original error', name: 'originalError' };
+      throw mssqlError;
+    });
+
+    // method under test
+    const queryResult: QueryResults = await client.executeQuery(context, 'SELECT * FROM bar', []);
+
+    expect(mockRequest).toThrow(expectedErrorMessage);
+    expect(queryResult.success).toBeFalsy();
+  });
+
+  test('should handle known mssql ConnectionError exceptions', async () => {
+    const expectedErrorMessage = 'Test ConnectionError exception';
+    const context = await createMockApplicationContext();
+    const connectionError = new ConnectionError(expectedErrorMessage);
+    connectionError.code = '';
+    connectionError.name = 'ConnectionError';
+    connectionError.message = expectedErrorMessage;
+    mockConnect.mockImplementation(() => {
+      throw connectionError;
+    });
+
+    // method under test
+    const queryResult: QueryResults = await client.executeQuery(context, 'SELECT * FROM bar', []);
+    expect(mockConnect).toThrow(expectedErrorMessage);
+    expect(queryResult.success).toBeFalsy();
+  });
+
+  test('should handle known mssql ConnectionError exceptions with AggregateErrors', async () => {
+    const expectedErrorMessage = 'Test ConnectionError exception with AggregateErrors';
+    const connectionError = new ConnectionError(expectedErrorMessage);
+    connectionError.code = '';
+    connectionError.name = 'ConnectionError';
+    connectionError.message = expectedErrorMessage;
+    connectionError.originalError = {
+      message: '',
+      name: 'AggregateError',
+      errors: [
+        { message: 'Something happen 01', name: '01', code: '' } as MSSQLError,
+        {
+          message: 'Something happen 02',
+          name: '02',
+          code: '',
+          errors: [
+            {
+              message: 'Agreggate error sub error 1',
+              name: '02.1',
+              code: '',
+            },
+          ],
+          originalError: {
+            name: '03',
+            message: 'Nested aggregate errors',
+            errors: [
+              { message: 'Nested aggregate error 04', name: '04', code: '' } as MSSQLError,
+              { message: 'Nested aggregate error 05', name: '05', code: '' } as MSSQLError,
+            ],
+          } as AggregateError,
+        } as ConnectionError,
+      ],
+    } as AggregateError;
+    mockConnect.mockImplementation(() => {
+      throw connectionError;
+    });
+
+    const context = await createMockApplicationContext();
+    // method under test
+    const queryResult: QueryResults = await client.executeQuery(context, 'SELECT * FROM bar', []);
+
+    expect(mockConnect).toThrow(expectedErrorMessage);
+    expect(queryResult.success).toBeFalsy();
+  });
+
+  test('should close connection pool when calling close', async () => {
+    const context = await createMockApplicationContext();
+    const client = new MssqlClient(context);
+
+    await client.close();
+    expect(mockConnectionPoolClose).toHaveBeenCalled();
+  });
+});

backend/functions/lib/adapters/gateways/abstract-mssql-client.test.ts

@@ -0,0 +1,75 @@
+import { QueryResults, IDbConfig } from '../types/database';
+import { createMockApplicationContext } from '../../testing/testing-utilities';
+import { AbstractMssqlClient } from './abstract-mssql-client';
+import { ApplicationContext } from '../types/basic';
+import { IResult } from 'mssql';
+
+type sqlConnect = {
+  request: () => void;
+  close: () => void;
+  query: () => void;
+};
+
+jest.mock('mssql', () => {
+  return {
+    ConnectionPool: jest.fn().mockImplementation(() => {
+      return {
+        connect: jest.fn().mockImplementation(
+          (): Promise<sqlConnect> =>
+            Promise.resolve({
+              request: jest.fn().mockImplementation(() => ({
+                input: jest.fn(),
+                query: jest
+                  .fn()
+                  .mockImplementation(
+                    (): Promise<IResult<string>> =>
+                      Promise.resolve({ recordset: 'test string' } as unknown as IResult<string>),
+                  ),
+              })),
+              close: jest.fn(),
+              query: jest
+                .fn()
+                .mockImplementation(
+                  (): Promise<string> =>
+                    Promise.resolve("this is not the string you're looking for"),
+                ),
+            }),
+        ),
+      };
+    }),
+  };
+});
+
+describe('Abstract MS-SQL client', () => {
+  test('should get appropriate results', async () => {
+    const applicationContext = await createMockApplicationContext();
+    // setup test
+    // execute method under test
+    const context = applicationContext;
+    const query = 'SELECT * FROM foo WHERE data = @param1 AND name=@param2';
+    const input = [
+      {
+        name: 'param1',
+        type: null,
+        value: 'dataValue',
+      },
+      {
+        name: 'param2',
+        type: null,
+        value: 'nameValue',
+      },
+    ];
+
+    // execute method under test
+    class TestDbClient extends AbstractMssqlClient {
+      constructor(context: ApplicationContext, config: IDbConfig, childModuleName: string) {
+        super(context, config, childModuleName);
+      }
+    }
+    const client = new TestDbClient(context, context.config.dxtrDbConfig, 'TEST_MODULE');
+    const queryResult: QueryResults = await client.executeQuery<string>(context, query, input);
+
+    // assert
+    expect(queryResult).toEqual({ results: 'test string', message: '', success: true });
+  });
+});

backend/functions/lib/adapters/gateways/abstract-mssql-client.ts

@@ -0,0 +1,113 @@
+import { config, ConnectionError, ConnectionPool, MSSQLError, IResult } from 'mssql';
+import { DbTableFieldSpec, IDbConfig, QueryResults } from '../types/database';
+import { Closable, deferClose } from '../../defer-close';
+import { ApplicationContext } from '../types/basic';
+
+export abstract class AbstractMssqlClient implements Closable {
+  private connectionPool: ConnectionPool;
+  private readonly moduleName: string;
+
+  protected constructor(context: ApplicationContext, dbConfig: IDbConfig, childModuleName: string) {
+    this.moduleName = `ABSTRACT-MSSQL-CLIENT (${childModuleName})`;
+    this.connectionPool = new ConnectionPool(dbConfig as config);
+    deferClose(context, this);
+  }
+
+  public async executeQuery<T = unknown>(
+    context: ApplicationContext,
+    query: string,
+    input?: DbTableFieldSpec[],
+  ): Promise<QueryResults> {
+    // we should do some sanitization here to eliminate sql injection issues
+    try {
+      const connection = await this.connectionPool.connect();
+      const request = connection.request();
+
+      if (typeof input != 'undefined') {
+        input.forEach((item) => {
+          request.input(item.name, item.type, item.value);
+        });
+      }
+      const result = (await request.query(query)) as IResult<T>;
+
+      const queryResults: QueryResults = {
+        results: result.recordset,
+        message: '',
+        success: true,
+      };
+
+      context.logger.info(this.moduleName, 'Closing connection.');
+
+      await connection.close();
+
+      return queryResults;
+    } catch (error) {
+      if (isConnectionError(error)) {
+        const errorMessages = [];
+        // No recursive function here. Limiting this to just 2 "errors" lists deep.
+        if (isAggregateError(error.originalError)) {
+          error.originalError.errors.reduce((acc, e) => {
+            if (isAggregateError(e)) {
+              e.errors.forEach((lowestE) => {
+                acc.push(lowestE.message);
+              });
+            } else {
+              acc.push(e.message);
+            }
+            return acc;
+          }, errorMessages);
+        }
+        errorMessages.push(error.message);
+        context.logger.error(this.moduleName, 'ConnectionError', { errorMessages });
+      } else if (isMssqlError(error)) {
+        const newError = {
+          error: {
+            name: error.name, // RequestError
+            description: error.message, // Timeout: Request failed to complete in 15000ms
+          },
+          originalError: {},
+          query,
+          input,
+        };
+        if (error.originalError) {
+          newError.originalError = {
+            name: error.originalError.name,
+            description: error.originalError.name,
+          };
+        }
+
+        context.logger.error(this.moduleName, 'MssqlError', newError);
+      } else {
+        context.logger.error(this.moduleName, error.message, { error, query, input });
+      }
+
+      // TODO May want to refactor to throw CamsError and remove returning QueryResults
+      const queryResult: QueryResults = {
+        results: {},
+        message: (error as Error).message,
+        success: false,
+      };
+      return queryResult;
+    }
+  }
+
+  public async close(): Promise<void> {
+    await this.connectionPool.close();
+  }
+}
+
+function isMssqlError(e): e is MSSQLError {
+  return e instanceof MSSQLError;
+}
+
+function isConnectionError(e): e is ConnectionError {
+  return e instanceof ConnectionError;
+}
+
+type AggregateError = Error & {
+  errors?: Error[];
+};
+
+function isAggregateError(e: unknown): e is AggregateError {
+  return e && 'errors' in (e as object);
+}