@natlibfi/melinda-rest-api-commons 6.0.1 → 6.2.0-alpha.0

package/test/utils.test.ts

@@ -0,0 +1,360 @@
+
+import assert from 'node:assert';
+import {test} from 'node:test';
+import httpStatus from 'http-status';
+import {Error as ApiError} from '@natlibfi/melinda-commons';
+import {
+  logError,
+  createImportJobState,
+  createRecordResponseItem,
+  addRecordResponseItem,
+  addRecordResponseItems
+} from '../src/utils.ts';
+
+test('createImportJobState should return state object for valid operation and state', () => {
+  const result = createImportJobState('CREATE', 'EMPTY');
+  assert.deepStrictEqual(result, {CREATE: 'EMPTY'});
+});
+
+test('createImportJobState should return query object when queryImportJobState is true', () => {
+  const result = createImportJobState('CREATE', 'EMPTY', true);
+  assert.deepStrictEqual(result, {'importJobState.CREATE': 'EMPTY'});
+});
+
+test('createImportJobState should throw for invalid state', () => {
+  assert.throws(() => {
+    createImportJobState('CREATE', 'INVALID_STATE');
+  }, new Error('Invalid IMPORT_JOB_STATE'));
+});
+
+test('createImportJobState should throw for invalid operation', () => {
+  assert.throws(() => {
+    createImportJobState('INVALID_OPERATION', 'EMPTY');
+  }, new Error('Invalid operation'));
+});
+
+test('createRecordResponseItem should use message from responsePayload.message', () => {
+  const result = createRecordResponseItem({
+    responsePayload: {message: 'payload message'},
+    responseStatus: 'UPDATED'
+  });
+  assert.equal(result.message, 'payload message');
+});
+
+test('createRecordResponseItem should use string responsePayload as message', () => {
+  const result = createRecordResponseItem({
+    responsePayload: 'string payload',
+    responseStatus: 'UPDATED'
+  });
+  assert.equal(result.message, 'string payload');
+});
+
+test('createRecordResponseItem should use empty message when payload has no message', () => {
+  const result = createRecordResponseItem({
+    responsePayload: {ids: ['123']},
+    responseStatus: 'UPDATED'
+  });
+  assert.equal(result.message, '');
+});
+
+test('createRecordResponseItem should default databaseId when id is omitted', () => {
+  const result = createRecordResponseItem({
+    responsePayload: {message: 'ok'},
+    responseStatus: 'UPDATED'
+  });
+  assert.equal(result.databaseId, '000000000');
+});
+
+test('createRecordResponseItem should set databaseId from id when provided', () => {
+  const result = createRecordResponseItem({
+    responsePayload: {message: 'ok'},
+    responseStatus: 'UPDATED',
+    id: '12345'
+  });
+  assert.equal(result.databaseId, '12345');
+});
+
+test('createRecordResponseItem should map UPDATED, CREATED and INVALID statuses', () => {
+  for (const responseStatus of ['UPDATED', 'CREATED', 'INVALID']) {
+    const result = createRecordResponseItem({
+      responsePayload: {message: 'msg'},
+      responseStatus
+    });
+    assert.equal(result.recordStatus, responseStatus);
+    assert.equal(result.detailedRecordStatus, responseStatus);
+    assert.equal(result.message, 'msg');
+  }
+});
+
+test('createRecordResponseItem should map SKIPPED status', () => {
+  const result = createRecordResponseItem({
+    responsePayload: {message: 'skipped'},
+    responseStatus: 'SKIPPED'
+  });
+  assert.equal(result.recordStatus, 'SKIPPED');
+  assert.equal(result.detailedRecordStatus, 'SKIPPED');
+});
+
+test('createRecordResponseItem should map SKIPPED_UPDATE to recordStatus SKIPPED', () => {
+  const result = createRecordResponseItem({
+    responsePayload: {message: 'skipped update'},
+    responseStatus: 'SKIPPED_UPDATE'
+  });
+  assert.equal(result.recordStatus, 'SKIPPED');
+  assert.equal(result.detailedRecordStatus, 'SKIPPED_UPDATE');
+});
+
+test('createRecordResponseItem should map CONFLICT duplicate message to DUPLICATE', () => {
+  const result = createRecordResponseItem({
+    responsePayload: {
+      message: 'Duplicates in database: 123',
+      ids: ['123', '456']
+    },
+    responseStatus: httpStatus.CONFLICT,
+    id: '123'
+  });
+  assert.equal(result.recordStatus, 'DUPLICATE');
+  assert.equal(result.detailedRecordStatus, 'DUPLICATE');
+  assert.deepStrictEqual(result.ids, ['123', '456']);
+});
+
+test('createRecordResponseItem should map CONFLICT MatchValidation message to ERROR', () => {
+  const result = createRecordResponseItem({
+    responsePayload: {
+      message: 'MatchValidation for all: something',
+      ids: ['123']
+    },
+    responseStatus: 'CONFLICT',
+    id: '123'
+  });
+  assert.equal(result.recordStatus, 'ERROR');
+  assert.equal(result.detailedRecordStatus, 'CONFLICT');
+});
+
+test('createRecordResponseItem should attach ids to CONFLICT when id does not match', () => {
+  const result = createRecordResponseItem({
+    responsePayload: {
+      message: 'conflict',
+      ids: ['789']
+    },
+    responseStatus: httpStatus.CONFLICT,
+    id: '123'
+  });
+  assert.equal(result.recordStatus, 'ERROR');
+  assert.equal(result.detailedRecordStatus, 'CONFLICT');
+  assert.deepStrictEqual(result.ids, ['789']);
+});
+
+test('createRecordResponseItem should omit ids from CONFLICT when ids matches id', () => {
+  const result = createRecordResponseItem({
+    responsePayload: {
+      message: 'conflict',
+      ids: ['123']
+    },
+    responseStatus: httpStatus.CONFLICT,
+    id: '123'
+  });
+  assert.equal(result.recordStatus, 'ERROR');
+  assert.equal(result.detailedRecordStatus, 'CONFLICT');
+  assert.equal(Object.hasOwn(result, 'ids'), false);
+});
+
+// a missing (undefined/null) responsePayload is rejected with a clear
+// message; objects and strings remain the valid payload forms
+test('createRecordResponseItem should throw with a missing responsePayload', () => {
+  assert.throws(
+    () => createRecordResponseItem({responsePayload: undefined, responseStatus: 'UPDATED'}),
+    /responsePayload must be an object or a string!/
+  );
+  assert.throws(
+    () => createRecordResponseItem({responsePayload: null, responseStatus: 'UPDATED'}),
+    /responsePayload must be an object or a string!/
+  );
+});
+
+// a string payload is a documented valid form and must not be rejected by the guard
+test('createRecordResponseItem accepts a string responsePayload', () => {
+  const item = createRecordResponseItem({responsePayload: 'Something went wrong', responseStatus: 422, id: '000000001'});
+  assert.equal(item.message, 'Something went wrong');
+});
+
+// for CONFLICT with an empty ids array, no `ids` field is
+// attached to the response item (previously the empty array was attached
+// because `ids[0] !== id` was true for an empty array).
+test('createRecordResponseItem should omit ids on CONFLICT when ids is empty', () => {
+  const result = createRecordResponseItem({
+    responsePayload: {
+      message: 'conflict',
+      ids: []
+    },
+    responseStatus: httpStatus.CONFLICT,
+    id: '123'
+  });
+  assert.equal(result.recordStatus, 'ERROR');
+  assert.equal(result.detailedRecordStatus, 'CONFLICT');
+  assert.equal(Object.hasOwn(result, 'ids'), false);
+});
+
+test('createRecordResponseItem should map UNPROCESSABLE_ENTITY to INVALID', () => {
+  const result = createRecordResponseItem({
+    responsePayload: {
+      message: 'unprocessable',
+      ids: ['456']
+    },
+    responseStatus: httpStatus.UNPROCESSABLE_ENTITY,
+    id: '123'
+  });
+  assert.equal(result.recordStatus, 'INVALID');
+  assert.equal(result.detailedRecordStatus, 'UNPROCESSABLE_ENTITY');
+  assert.deepStrictEqual(result.ids, ['456']);
+});
+
+test('createRecordResponseItem should map UNPROCESSABLE_ENTITY without ids when matching', () => {
+  const result = createRecordResponseItem({
+    responsePayload: {
+      message: 'unprocessable',
+      ids: ['123']
+    },
+    responseStatus: 'UNPROCESSABLE_ENTITY',
+    id: '123'
+  });
+  assert.equal(result.recordStatus, 'INVALID');
+  assert.equal(result.detailedRecordStatus, 'UNPROCESSABLE_ENTITY');
+  assert.equal(Object.hasOwn(result, 'ids'), false);
+});
+
+test('createRecordResponseItem should map NOT_FOUND to ERROR', () => {
+  const result = createRecordResponseItem({
+    responsePayload: {message: 'not found'},
+    responseStatus: httpStatus.NOT_FOUND
+  });
+  assert.equal(result.recordStatus, 'ERROR');
+  assert.equal(result.detailedRecordStatus, 'NOT_FOUND');
+  assert.equal(result.message, 'not found');
+});
+
+test('createRecordResponseItem should map FORBIDDEN to ERROR', () => {
+  const result = createRecordResponseItem({
+    responsePayload: {message: 'forbidden'},
+    responseStatus: httpStatus.FORBIDDEN
+  });
+  assert.equal(result.recordStatus, 'ERROR');
+  assert.equal(result.detailedRecordStatus, 'FORBIDDEN');
+  assert.equal(result.message, 'forbidden');
+});
+
+test('createRecordResponseItem should map unknown status to ERROR with appended message', () => {
+  const result = createRecordResponseItem({
+    responsePayload: {message: 'some message'},
+    responseStatus: 'SOMETHING_ELSE'
+  });
+  assert.equal(result.recordStatus, 'ERROR');
+  assert.equal(result.detailedRecordStatus, 'SOMETHING_ELSE');
+  assert.equal(result.message, 'some message - Unknown recordStatus: SOMETHING_ELSE');
+});
+
+test('createRecordResponseItem should map UNKNOWN status to ERROR with ids', () => {
+  const result = createRecordResponseItem({
+    responsePayload: {
+      message: 'unknown',
+      ids: ['42']
+    },
+    responseStatus: 'UNKNOWN'
+  });
+  assert.equal(result.recordStatus, 'ERROR');
+  assert.equal(result.detailedRecordStatus, 'UNKNOWN');
+  assert.deepStrictEqual(result.ids, ['42']);
+});
+
+test('addRecordResponseItem should push the recordResponseItem via mongoOperator', async () => {
+  let captured: unknown;
+  const mongoOperator = {
+    pushMessages: async (args: unknown) => {
+      captured = args;
+    }
+  };
+  const recordResponseItem = {databaseId: '000000000'};
+  const result = await addRecordResponseItem({
+    recordResponseItem,
+    correlationId: 'corr-1',
+    mongoOperator
+  });
+  assert.equal(result, true);
+  assert.deepStrictEqual(captured, {
+    correlationId: 'corr-1',
+    messages: [recordResponseItem],
+    messageField: 'records'
+  });
+});
+
+test('addRecordResponseItem should throw for non-object input', async () => {
+  const mongoOperator = {
+    pushMessages: async () => {}
+  };
+  for (const badInput of [undefined, null, 'not-an-object', 42, [{databaseId: '1'}]]) {
+    await assert.rejects(
+      addRecordResponseItem({
+        recordResponseItem: badInput,
+        correlationId: 'corr-42',
+        mongoOperator
+      }),
+      new Error('RecordResponseItem is not an object!')
+    );
+  }
+});
+
+test('addRecordResponseItems should push all items in one call', async () => {
+  let captured: unknown;
+  let callCount = 0;
+  const mongoOperator = {
+    pushMessages: async (args: unknown) => {
+      callCount += 1;
+      captured = args;
+    }
+  };
+  const items = [
+    {databaseId: '1'},
+    {databaseId: '2'}
+  ];
+  const result = await addRecordResponseItems({
+    recordResponseItems: items,
+    correlationId: 'corr-2',
+    mongoOperator
+  });
+  assert.equal(result, true);
+  assert.equal(callCount, 1);
+  assert.deepStrictEqual(captured, {
+    correlationId: 'corr-2',
+    messages: items,
+    messageField: 'records'
+  });
+});
+
+test('addRecordResponseItems should throw for non-array input', async () => {
+  const mongoOperator = {
+    pushMessages: async () => {}
+  };
+  await assert.rejects(
+    addRecordResponseItems({
+      recordResponseItems: 'not-an-array',
+      correlationId: 'corr-3',
+      mongoOperator
+    }),
+    new Error('RecordResponseItems is not an array!')
+  );
+});
+
+test('logError should not throw for ApiError, SIGINT and regular errors', () => {
+  assert.doesNotThrow(() => {
+    logError(new ApiError(404, 'Not found'));
+  });
+  assert.doesNotThrow(() => {
+    logError('SIGINT');
+  });
+  assert.doesNotThrow(() => {
+    logError(new Error('some error'));
+  });
+  assert.doesNotThrow(() => {
+    logError('plain string without stack');
+  });
+});

package/tsconfig.json

@@ -0,0 +1,62 @@
+{
+  "include": [
+    "src"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ],
+  "compilerOptions": {
+    // File Layout
+    "rootDir": "./src",
+    "outDir": "./dist",
+    // Environment Settings
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "target": "esnext",
+    "typeRoots": [
+      "./node_modules/@types"
+    ],
+    "types": [
+      "node"
+    ],
+    "lib": [
+      "esnext"
+    ],
+    // Other Outputs
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+    // Stricter Typechecking Options
+    "noUncheckedIndexedAccess": true,
+    // Style Options
+    "noImplicitReturns": true,
+    "noImplicitOverride": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noPropertyAccessFromIndexSignature": true,
+    // Recommended Options
+    "strict": true,
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true,
+    "allowImportingTsExtensions": true,
+    "noEmit": false,
+    // Customized options
+    "allowJs": true,
+    "checkJs": true,
+    "esModuleInterop": true,
+    "allowUnreachableCode": false,
+    "strictFunctionTypes": true,
+    "strictNullChecks": true,
+    "removeComments": true,
+    // Only allow syntax accepted by Node >= 23.6
+    "erasableSyntaxOnly": true,
+    // Proposed options from Node docs: https://nodejs.org/api/typescript.html#type-stripping
+    "rewriteRelativeImportExtensions": true,
+    "verbatimModuleSyntax": true,
+    "forceConsistentCasingInFileNames": true
+  }
+}

package/tsconfig.test.json

@@ -0,0 +1,17 @@
+{
+  "extends": "./tsconfig.json",
+  "include": [
+    "src",
+    "test"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ],
+  "compilerOptions": {
+    // Typechecking only — never emits. The build config (tsconfig.json)
+    // keeps rootDir ./src so `npm run build` still emits only src/ -> dist/.
+    "noEmit": true,
+    "rootDir": "."
+  }
+}

package/dist/helpers/fix-utils.js

@@ -1,39 +0,0 @@
-export function removeSubfield(field, code) {
-  if (!isNaN(field.tag) && parseInt(field.tag, 10) >= 10) {
-    const filteredSubfields = field.subfields.filter((sf) => sf.code !== code);
-    if (filteredSubfields.length < 1) {
-      return false;
-    }
-    return {
-      tag: field.tag,
-      ind1: field.ind1,
-      ind2: field.ind2,
-      subfields: filteredSubfields
-    };
-  }
-  return field;
-}
-export function sortFieldsBySubfieldValue(fields, subfieldCode) {
-  return [...fields].sort((a, b) => {
-    const a1value = getFirstSubfieldValue(a, subfieldCode);
-    const b1value = getFirstSubfieldValue(b, subfieldCode);
-    if (a1value && !b1value) {
-      return -1;
-    }
-    if (!a1value && b1value) {
-      return 1;
-    }
-    if (a1value > b1value) {
-      return 1;
-    }
-    if (b1value > a1value) {
-      return -1;
-    }
-    return 0;
-  });
-  function getFirstSubfieldValue(field, subfieldCode2) {
-    const subs = field.subfields ? field.subfields.filter((subf) => subf.code === subfieldCode2) : [];
-    return subs.length > 0 ? subs[0].value : "";
-  }
-}
-//# sourceMappingURL=fix-utils.js.map

package/dist/helpers/fix-utils.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/helpers/fix-utils.js"],
-  "sourcesContent": ["export function removeSubfield(field, code) {\n\n  // Handle non-numeric fields, and fields with a numeric tag of 010 and greater\n  // Aleph's FMT as a controlfield might be a problem\n  if (!isNaN(field.tag) && parseInt(field.tag, 10) >= 10) {\n\n    const filteredSubfields = field.subfields.filter(sf => sf.code !== code);\n\n    // Remove whole field if there are no subfields left\n    if (filteredSubfields.length < 1) {\n      return false;\n    }\n\n    return {\n      tag: field.tag,\n      ind1: field.ind1,\n      ind2: field.ind2,\n      subfields: filteredSubfields\n    };\n  }\n  // return controlFields as is\n  return field;\n}\n\n\n// sort fields by value of each fields first subfield with subfielCode\nexport function sortFieldsBySubfieldValue(fields, subfieldCode) {\n  return [...fields].sort((a, b) => {\n    const a1value = getFirstSubfieldValue(a, subfieldCode);\n    const b1value = getFirstSubfieldValue(b, subfieldCode);\n    if (a1value && !b1value) {\n      return -1;\n    }\n    if (!a1value && b1value) {\n      return 1;\n    }\n    if (a1value > b1value) {\n      return 1;\n    }\n    if (b1value > a1value) {\n      return -1;\n    }\n    return 0;\n  });\n  // get value for the for instance of subfield with subfieldCode\n  function getFirstSubfieldValue(field, subfieldCode) {\n    const subs = field.subfields ? field.subfields.filter(subf => subf.code === subfieldCode) : [];\n    return subs.length > 0 ? subs[0].value : '';\n  }\n}\n"],
-  "mappings": "AAAO,gBAAS,eAAe,OAAO,MAAM;AAI1C,MAAI,CAAC,MAAM,MAAM,GAAG,KAAK,SAAS,MAAM,KAAK,EAAE,KAAK,IAAI;AAEtD,UAAM,oBAAoB,MAAM,UAAU,OAAO,QAAM,GAAG,SAAS,IAAI;AAGvE,QAAI,kBAAkB,SAAS,GAAG;AAChC,aAAO;AAAA,IACT;AAEA,WAAO;AAAA,MACL,KAAK,MAAM;AAAA,MACX,MAAM,MAAM;AAAA,MACZ,MAAM,MAAM;AAAA,MACZ,WAAW;AAAA,IACb;AAAA,EACF;AAEA,SAAO;AACT;AAIO,gBAAS,0BAA0B,QAAQ,cAAc;AAC9D,SAAO,CAAC,GAAG,MAAM,EAAE,KAAK,CAAC,GAAG,MAAM;AAChC,UAAM,UAAU,sBAAsB,GAAG,YAAY;AACrD,UAAM,UAAU,sBAAsB,GAAG,YAAY;AACrD,QAAI,WAAW,CAAC,SAAS;AACvB,aAAO;AAAA,IACT;AACA,QAAI,CAAC,WAAW,SAAS;AACvB,aAAO;AAAA,IACT;AACA,QAAI,UAAU,SAAS;AACrB,aAAO;AAAA,IACT;AACA,QAAI,UAAU,SAAS;AACrB,aAAO;AAAA,IACT;AACA,WAAO;AAAA,EACT,CAAC;AAED,WAAS,sBAAsB,OAAOA,eAAc;AAClD,UAAM,OAAO,MAAM,YAAY,MAAM,UAAU,OAAO,UAAQ,KAAK,SAASA,aAAY,IAAI,CAAC;AAC7F,WAAO,KAAK,SAAS,IAAI,KAAK,CAAC,EAAE,QAAQ;AAAA,EAC3C;AACF;",
-  "names": ["subfieldCode"]
-}

package/eslint.config.js

@@ -1,53 +0,0 @@
-// Eslint configuration object for src
-const configSrc = {
-  files: [
-    "src/*",
-    "tests/*"
-  ],
-  linterOptions: {
-    reportUnusedDisableDirectives: true,
-  },
-  rules: {
-    "no-console": "warn",
-    "eqeqeq": ["error", "always"],
-    "no-const-assign": "error",
-    "max-depth": ["warn", 4],
-    "max-lines": ["warn", 500],
-    "max-lines-per-function": ["warn", {"max": 100}],
-    "no-else-return": ["error", {allowElseIf: false}],
-    "no-plusplus": [
-      "error",
-      {
-        "allowForLoopAfterthoughts": true
-      }
-    ],
-    "array-callback-return": [
-      "error",
-      {
-        "checkForEach": false
-      }
-    ],
-    "no-unused-vars": [
-      "error",
-      {
-        "argsIgnorePattern": "next"
-      }
-    ],
-    "no-warning-comments": "off"
-  }
-};
-
-// Eslint configuration object for globally ignoring .js files
-// - ignore all files that start with a dot
-// - ignore all files inside directories named 'dist'
-const configIgnores = {
-  ignores: [
-    "**/.*",
-    "**/dist/"
-  ]
-};
-
-export default [
-  configSrc,
-  configIgnores
-];

package/tests/helpers/fix.test.js

@@ -1,41 +0,0 @@
-import assert from 'node:assert';
-import createDebugLogger from 'debug';
-import {MarcRecord} from '@natlibfi/marc-record';
-import {READERS} from '@natlibfi/fixura';
-import generateTests from '@natlibfi/fixugen';
-import {fixRecord} from '../../src/helpers/fix.js';
-import * as fixSettings from '../../src/helpers/fix-constants.js';
-// import inspect from 'util';
-
-const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons:fix:test');
-const debugData = debug.extend('data');
-
-generateTests({
-  callback,
-  path: [import.meta.dirname, '..', '..', 'test-fixtures', 'fix'],
-  recurse: true,
-  useMetadataFile: true,
-  fixura: {
-    failWhenNotFound: false,
-    reader: READERS.JSON
-  }
-});
-
-function callback({getFixture, settings = undefined}) {
-  if (settings !== undefined && fixSettings[settings] === undefined) {
-    throw new Error(`There are no settings ${settings} defined!`);
-  }
-  const runSettings = fixSettings[settings] || settings;
-
-  const record = new MarcRecord(getFixture('record.json'), {subfieldValues: false});
-  const expectedRecord = getFixture('expectedRecord.json');
-
-  debug(`Running fixer with settings ${settings}.`);
-  debugData(JSON.stringify(runSettings, null, 2));
-
-  const resultRecord = fixRecord(record, runSettings);
-  debugData(`Result:   ${JSON.stringify(resultRecord)}`);
-  debugData(`Expected: ${JSON.stringify(expectedRecord)}`);
-  assert.deepStrictEqual(resultRecord, expectedRecord);
-
-}

package/tests/mongoLog.test.js

@@ -1,84 +0,0 @@
-import assert from 'node:assert';
-import {READERS} from '@natlibfi/fixura';
-import generateTests from '@natlibfi/fixugen';
-import mongoFixturesFactory from '@natlibfi/fixura-mongo';
-import createMongoLogOperator from '../src/mongoLog.js';
-
-let mongoFixtures; // eslint-disable-line functional/no-let
-
-generateTests({
-  callback,
-  path: [import.meta.dirname, '..', 'test-fixtures', 'mongoLog'],
-  recurse: false,
-  useMetadataFile: true,
-  fixura: {
-    failWhenNotFound: true,
-    reader: READERS.JSON
-  },
-  hooks: {
-    before: async () => {
-      await initMongofixtures();
-    },
-    beforeEach: () => mongoFixtures.clear(),
-    afterEach: () => mongoFixtures.clear(),
-    after: async () => {
-      await mongoFixtures.close();
-    }
-  }
-});
-
-async function initMongofixtures() {
-  mongoFixtures = await mongoFixturesFactory({
-    rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongoLog'],
-    gridFS: {bucketName: 'blobs'},
-    useObjectId: true,
-    format: {
-      creationTime: v => new Date(v),
-      modificationTime: v => new Date(v)
-    }
-  });
-}
-
-async function callback({
-  getFixture,
-  functionName,
-  params,
-  preFillDb = false
-}) {
-  const mongoUri = await mongoFixtures.getUri();
-  const mongoLogOperator = await createMongoLogOperator(mongoUri, '');
-  const expectedResult = await getFixture('expectedResult.json');
-  // console.log(typeof mongoUri); // eslint-disable-line
-
-  if (preFillDb) {
-    await mongoFixtures.populate(getFixture('dbContents.json'));
-  }
-
-  if (functionName === 'addLogItem') {
-    await mongoLogOperator.addLogItem(params);
-    const dump = await mongoFixtures.dump();
-    return assert.deepStrictEqual(dump.logs[0]['0'], expectedResult);
-  }
-
-  if (functionName === 'getListOfCatalogers') {
-    const result = await mongoLogOperator.getListOfCatalogers();
-    // console.log(result); // eslint-disable-line
-
-    return assert.deepEqual(result, expectedResult);
-  }
-
-  if (functionName === 'getExpandedListOfLogs') {
-    const result = await mongoLogOperator.getExpandedListOfLogs(params);
-    // console.log(result); // eslint-disable-line
-
-    return assert.deepEqual(result, expectedResult);
-  }
-
-  if (functionName === 'getListOfLogs') {
-    const result = await mongoLogOperator.getListOfLogs(params);
-    // console.log(result); // eslint-disable-line
-    return assert.deepEqual(result, expectedResult);
-  }
-  throw new Error(`Unknown functionName: ${functionName}`);
-}
-