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

package/{tests/mongo-set-state.test.js → test/mongo-set-state.test.ts}

@@ -4,10 +4,10 @@ import {READERS} from '@natlibfi/fixura';
 import mongoFixturesFactory from '@natlibfi/fixura-mongo';
 import generateTests from '@natlibfi/fixugen';
 //import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils.js';
-import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils.js';
+import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils.ts';
 
 
-let mongoFixtures; // eslint-disable-line functional/no-let
+let mongoFixtures: any;
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:set-state:test');
 
 generateTests({
@@ -41,14 +41,14 @@ generateTests({
 
 async function initMongofixtures() {
   mongoFixtures = await mongoFixturesFactory({
-    recurse: false,
     rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongo', 'set-state'],
     gridFS: {bucketName: 'foobar'},
     useObjectId: true
   });
 }
 
-async function callback({
+async function callback(callbackParams: Record<string, any>) {
+  const {
   getFixture,
   functionName,
   params,
@@ -57,14 +57,14 @@ async function callback({
   expectedToThrow = false,
   expectedErrorMessage = '',
   expectedErrorStatus = ''
-}) {
+  } = callbackParams;
 
   const mongoOperator = await getMongoOperator(mongoFixtures);
   const expectedResult = await getFixture('expectedResult.json');
 
   await doPreFillDb(preFillDb);
 
-  async function doPreFillDb(preFillDb) {
+  async function doPreFillDb(preFillDb: boolean) {
     if (preFillDb) {
       await mongoFixtures.populate(getFixture('dbContents.json'));
       return;

package/test/mongoLog-protect.test.ts

@@ -0,0 +1,182 @@
+import assert from 'node:assert';
+import {test, before, after} from 'node:test';
+import mongoFixturesFactory from '@natlibfi/fixura-mongo';
+import {Error as ApiError} from '@natlibfi/melinda-commons';
+import createMongoLogOperator from '../src/mongoLog.ts';
+import type {MongoLogOperator} from '../src/mongoLog.ts';
+
+let mongoFixtures: any;
+let mongoLogOperator: MongoLogOperator;
+
+async function initMongofixtures() {
+  mongoFixtures = await mongoFixturesFactory({
+    rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongoLog'],
+    gridFS: {bucketName: 'blobs'},
+    useObjectId: true,
+    format: {
+      logs: {
+        creationTime: v => new Date(String(v)),
+        modificationTime: v => new Date(String(v))
+      }
+    }
+  });
+  const mongoUri = await mongoFixtures.getUri();
+  mongoLogOperator = await createMongoLogOperator(mongoUri, '');
+}
+
+async function cleanup() {
+  await mongoFixtures.clear();
+  await mongoFixtures.close();
+}
+
+before(async () => {
+  await initMongofixtures();
+});
+
+after(async () => {
+  await cleanup();
+});
+
+test('protect is idempotent: protecting an already protected log keeps it protected', async () => {
+  const logItem = {
+    logItemType: 'MERGE_LOG',
+    cataloger: 'IMP_TEST1',
+    correlationId: '22222222-2222-4222-8222-222222222222',
+    blobSequence: 1
+  };
+  await mongoLogOperator.addLogItem(logItem);
+
+  await mongoLogOperator.protect(logItem.correlationId, logItem.blobSequence);
+
+  // a second call must not toggle the log back to unprotected
+  await mongoLogOperator.protect(logItem.correlationId, logItem.blobSequence);
+
+  const {logs} = await mongoFixtures.dump();
+  const own = logs.filter((doc: any) => doc.correlationId === logItem.correlationId);
+  assert.equal(own.length, 1);
+  assert.equal(own[0].protected, true);
+});
+
+test('unprotect sets protected to false after protect', async () => {
+  const logItem = {
+    logItemType: 'MERGE_LOG',
+    cataloger: 'IMP_TEST1',
+    correlationId: '33333333-3333-4333-8333-333333333333',
+    blobSequence: 2
+  };
+  await mongoLogOperator.addLogItem(logItem);
+
+  await mongoLogOperator.protect(logItem.correlationId, logItem.blobSequence);
+  const result = await mongoLogOperator.unprotect(logItem.correlationId, logItem.blobSequence);
+  assert.equal(result.modifiedCount, 1);
+
+  const {logs} = await mongoFixtures.dump();
+  const own = logs.filter((doc: any) => doc.correlationId === logItem.correlationId);
+  assert.equal(own.length, 1);
+  assert.equal(own[0].protected, false);
+});
+
+test('unprotect without blobSequence unprotects all logs of the correlationId', async () => {
+  const correlationId = '44444444-4444-4444-8444-444444444444';
+  await mongoLogOperator.addLogItem({logItemType: 'MERGE_LOG', cataloger: 'IMP_TEST1', correlationId, blobSequence: 1});
+  await mongoLogOperator.addLogItem({logItemType: 'MATCH_LOG', cataloger: 'IMP_TEST1', correlationId, blobSequence: 2});
+
+  await mongoLogOperator.protect(correlationId);
+  const result = await mongoLogOperator.unprotect(correlationId);
+  assert.equal(result.modifiedCount, 2);
+
+  const {logs} = await mongoFixtures.dump();
+  const own = logs.filter((doc: any) => doc.correlationId === correlationId);
+  assert.equal(own.length, 2);
+  assert.ok(own.every((doc: any) => doc.protected === false));
+});
+
+test('getExpandedListOfLogs throws ApiError when logItemTypes is provided but is not an array', async () => {
+  await assert.rejects(
+    () => mongoLogOperator.getExpandedListOfLogs({logItemTypes: 'MERGE_LOG'}),
+    (error) => {
+      assert.ok(error instanceof ApiError);
+      assert.strictEqual(error.status, 400);
+      assert.ok((error.payload as string).includes('logItemTypes must be an array'));
+      return true;
+    }
+  );
+});
+
+test('getExpandedListOfLogs throws ApiError when logItemTypes contains an unknown element', async () => {
+  await assert.rejects(
+    () => mongoLogOperator.getExpandedListOfLogs({logItemTypes: ['MERGE_LOG', 'BOGUS_LOG']}),
+    (error) => {
+      assert.ok(error instanceof ApiError);
+      assert.strictEqual(error.status, 400);
+      assert.ok((error.payload as string).includes('Unknown logItemType'));
+      return true;
+    }
+  );
+});
+
+test('getExpandedListOfLogs uses Date instances for dateBefore and dateAfter as-is', async () => {
+  const logItem = {
+    logItemType: 'MERGE_LOG',
+    cataloger: 'IMP_TEST1',
+    correlationId: '66666666-6666-4666-8666-666666666666',
+    blobSequence: 1
+  };
+  await mongoLogOperator.addLogItem(logItem);
+  // both bounds as Date instances: the match must use them as-is (no UTC
+  // midnight anchoring), so the freshly created log is inside the window
+  const result = await mongoLogOperator.getExpandedListOfLogs({
+    logItemTypes: ['MERGE_LOG'],
+    catalogers: ['IMP_TEST1'],
+    dateBefore: new Date(Date.now() + 60 * 60 * 1000),
+    dateAfter: new Date(Date.now() - 60 * 60 * 1000)
+  });
+  const own = result.filter(entry => entry.correlationId === logItem.correlationId);
+  assert.equal(own.length, 1);
+  assert.equal(own[0]?.logCount, 1);
+});
+
+test('getListOfLogs throws ApiError 500 for an unknown logItemType', async () => {
+  await assert.rejects(
+    () => mongoLogOperator.getListOfLogs('BOGUS_LOG'),
+    (error) => {
+      assert.ok(error instanceof ApiError);
+      assert.strictEqual(error.status, 500);
+      assert.ok((error.payload as string).includes('Unknown logItemType'));
+      return true;
+    }
+  );
+});
+
+test('addLogItem with an unknown logItemType does not throw (warn path)', async () => {
+  const logItem = {
+    logItemType: 'BOGUS_LOG',
+    cataloger: 'IMP_TEST1',
+    correlationId: '77777777-7777-4777-8777-777777777777',
+    blobSequence: 1
+  };
+  // checkLogItemType is called with errorUnknown=false for addLogItem, so an
+  // unknown type must only warn, not throw, and the log must be stored
+  await mongoLogOperator.addLogItem(logItem);
+
+  const {logs} = await mongoFixtures.dump();
+  const own = logs.filter((doc: any) => doc.correlationId === logItem.correlationId);
+  assert.equal(own.length, 1);
+  assert.equal(own[0].logItemType, 'BOGUS_LOG');
+});
+
+test('getExpandedListOfLogs with a valid logItemTypes array still works', async () => {
+  const logItem = {
+    logItemType: 'MERGE_LOG',
+    cataloger: 'IMP_TEST1',
+    correlationId: '55555555-5555-4555-8555-555555555555',
+    blobSequence: 1
+  };
+  await mongoLogOperator.addLogItem(logItem);
+  const result = await mongoLogOperator.getExpandedListOfLogs({logItemTypes: ['MERGE_LOG'], catalogers: ['IMP_TEST1'], dateBefore: new Date(Date.now() + 60 * 60 * 1000)});
+  const own = result.filter(entry => entry.correlationId === logItem.correlationId);
+  assert.equal(own.length, 1);
+  assert.equal(own[0]?.logItemType, 'MERGE_LOG');
+  assert.equal(own[0]?.cataloger, 'IMP_TEST1');
+  assert.equal(own[0]?.logCount, 1);
+});

package/test/mongoLog.test.ts

@@ -0,0 +1,191 @@
+import assert from 'node:assert';
+import {READERS} from '@natlibfi/fixura';
+import {Error as ApiError} from '@natlibfi/melinda-commons';
+import generateTests from '@natlibfi/fixugen';
+import mongoFixturesFactory from '@natlibfi/fixura-mongo';
+import createMongoLogOperator from '../src/mongoLog.ts';
+
+let mongoFixtures: any;
+
+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,
+    // fixura-mongo format is keyed by COLLECTION name, so the old
+    // {creationTime, modificationTime} form never applied and the fixtures
+    // stored creationTime as an ISO string (production addLogItem stores a
+    // Date). Format under the 'logs' collection so tests see the real
+    // production shape.
+    format: {
+      logs: {
+        creationTime: v => new Date(String(v)),
+        modificationTime: v => new Date(String(v))
+      }
+    }
+  });
+}
+
+async function callback(callbackParams: Record<string, any>) {
+  const {
+  getFixture,
+  functionName,
+  params,
+  preFillDb = false,
+  expectError = false,
+  expectedErrorStatus = 500
+  } = callbackParams;
+  const mongoUri = await mongoFixtures.getUri();
+  const mongoLogOperator = await createMongoLogOperator(mongoUri, '');
+  const expectedResult = expectError ? undefined : await getFixture('expectedResult.json');
+
+  if (expectError) {
+    // assert the throw (like the removeBySequences branch below)
+    if (functionName === 'protect') {
+      const [correlationId, blobSequence] = params;
+      return assert.rejects(
+        () => mongoLogOperator.protect(correlationId, blobSequence),
+        error => error instanceof ApiError && error.status === expectedErrorStatus
+      );
+    }
+    if (functionName === 'remove') {
+      const [correlationId, force] = params;
+      return assert.rejects(
+        () => mongoLogOperator.remove(correlationId, force),
+        error => error instanceof ApiError && error.status === expectedErrorStatus
+      );
+    }
+    if (functionName === 'removeBySequences') {
+      const [correlationId, sequences, force] = params;
+      return assert.rejects(
+        () => mongoLogOperator.removeBySequences(correlationId, sequences, force),
+        error => error instanceof ApiError && error.status === expectedErrorStatus
+      );
+    }
+    throw new Error(`Unknown functionName with expectError: ${functionName}`);
+  }
+
+  // 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(normalizeDates(result), expectedResult);
+  }
+
+  if (functionName === 'getListOfLogs') {
+    const result = await mongoLogOperator.getListOfLogs(params);
+    // console.log(result); // eslint-disable-line
+    return assert.deepEqual(result, expectedResult);
+  }
+
+  if (functionName === 'query') {
+    const result = normalizeDates(await mongoLogOperator.query(params));
+    // console.log(result); // eslint-disable-line
+    return assert.deepEqual(result, expectedResult);
+  }
+
+  if (functionName === 'queryById') {
+    const [correlationId, logItemType, skip, limit] = params;
+    const result = normalizeDates(await mongoLogOperator.queryById(correlationId, logItemType, skip, limit));
+    // console.log(result); // eslint-disable-line
+    return assert.deepEqual(result, expectedResult);
+  }
+
+  if (functionName === 'getListOfCorrelationIds') {
+    const result = await mongoLogOperator.getListOfCorrelationIds();
+    // console.log(result); // eslint-disable-line
+    return assert.deepEqual(result, expectedResult);
+  }
+
+  if (functionName === 'protect') {
+    const [correlationId, blobSequence] = params;
+    const result = await mongoLogOperator.protect(correlationId, blobSequence);
+    assert.deepEqual(result, expectedResult);
+    const remaining = (await dumpRemaining()).map(doc => {
+      // protect() sets modificationTime to the current time, so it can't be
+      // compared against a static fixture
+      const fixed = {...doc};
+      delete fixed.modificationTime;
+      return fixed;
+    });
+    return assert.deepEqual(remaining, getFixture('expectedRemaining.json'));
+  }
+
+  if (functionName === 'remove') {
+    const [correlationId, force] = params;
+    const result = await mongoLogOperator.remove(correlationId, force);
+    assert.deepEqual(result, expectedResult);
+    return assert.deepEqual(await dumpRemaining(), getFixture('expectedRemaining.json'));
+  }
+
+  if (functionName === 'removeBySequences') {
+    const [correlationId, sequences, force] = params;
+    const result = await mongoLogOperator.removeBySequences(correlationId, sequences, force);
+    assert.deepEqual(result, expectedResult);
+    return assert.deepEqual(await dumpRemaining(), getFixture('expectedRemaining.json'));
+  }
+
+  throw new Error(`Unknown functionName: ${functionName}`);
+}
+
+// Dump the surviving logs, normalized for comparison against a fixture
+async function dumpRemaining() {
+  return normalizeDates((await mongoFixtures.dump()).logs);
+}
+
+// Convert BSON Dates in the result to ISO strings and drop _id, so the result
+// can be compared with the plain strings in expectedResult.json /
+// expectedRemaining.json (fixura-mongo dump also strips _id)
+function normalizeDates(docs: any[]): any[] {
+  return docs.map(doc => {
+    const fixed = {...doc};
+    delete fixed._id;
+    if (fixed.creationTime instanceof Date) {
+      fixed.creationTime = fixed.creationTime.toISOString();
+    }
+    if (fixed.modificationTime instanceof Date) {
+      fixed.modificationTime = fixed.modificationTime.toISOString();
+    }
+    return fixed;
+  });
+}

package/{tests/testUtils.js → test/testUtils.ts}

@@ -1,23 +1,39 @@
-
 import assert from 'node:assert';
 import createDebugLogger from 'debug';
-import createMongoOperator from '../src/mongo.js';
+import type {Readable} from 'node:stream';
+import createMongoOperator from '../src/mongo.ts';
 
 
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:test');
 
-export async function getMongoOperator(mongoFixtures) {
+// the fixura-mongo fixtures object is intentionally untyped in tests
+// (fixture-driven scaffolding, see the eslint house rules for test/)
+export async function getMongoOperator(mongoFixtures: any) {
   const mongoUri = await mongoFixtures.getUri();
   const mongoOperator = await createMongoOperator(mongoUri, 'foobar', '');
   return mongoOperator;
 }
 
-export async function compareToFirstDbEntry({mongoFixtures, expectedResult, expectModificationTime = false, formatDates = true, expectedFileCount = undefined}) {
+interface DbEntryCompareParams {
+  mongoFixtures: any;
+  expectedResult: unknown;
+  expectModificationTime?: boolean;
+  formatDates?: boolean;
+  expectedFileCount?: number;
+}
+
+export async function compareToFirstDbEntry(params: DbEntryCompareParams) {
+  const {mongoFixtures, expectedResult, expectModificationTime = false, formatDates = true, expectedFileCount = undefined} = params;
   const result = await compareToDbEntry({mongoFixtures, expectedResult, resultIndex: 0, expectModificationTime, formatDates, expectedFileCount});
   return result;
 }
 
-export async function compareToDbEntry({mongoFixtures, expectedResult, resultIndex = 0, expectModificationTime = false, formatDates = true, expectedFileCount = undefined}) {
+interface DbEntryParams extends DbEntryCompareParams {
+  resultIndex?: number;
+}
+
+export async function compareToDbEntry(params: DbEntryParams) {
+  const {mongoFixtures, expectedResult, resultIndex = 0, expectModificationTime = false, formatDates = true, expectedFileCount = undefined} = params;
   const dump = await mongoFixtures.dump();
   debug(`--- We have ${dump.foobar.length} documents in db`);
   debug(dump.foobar);
@@ -39,7 +55,13 @@ export async function compareToDbEntry({mongoFixtures, expectedResult, resultInd
   return;
 }
 
-function checkFileCount({dump, expectedFileCount}) {
+interface CheckFileCountParams {
+  dump: any;
+  expectedFileCount: number | undefined;
+}
+
+function checkFileCount(params: CheckFileCountParams) {
+  const {dump, expectedFileCount} = params;
   if (expectedFileCount !== undefined) {
     const fileCount = dump['foobar.files']?.length;
     debug(`--- We have ${fileCount} files in db`);
@@ -50,7 +72,13 @@ function checkFileCount({dump, expectedFileCount}) {
 
 }
 
-function checkModificationTime({result, expectModificationTime}) {
+interface CheckModificationTimeParams {
+  result: any;
+  expectModificationTime: boolean;
+}
+
+function checkModificationTime(params: CheckModificationTimeParams) {
+  const {result, expectModificationTime} = params;
   if (expectModificationTime) {
     debug('Check if modificationTime was edited');
     const isNotEmpty = result.modificationTime !== '';
@@ -62,7 +90,7 @@ function checkModificationTime({result, expectModificationTime}) {
 }
 
 
-export function formatQueueItem(queueItem) {
+export function formatQueueItem(queueItem: any): any {
   const filteredQueueItem = {
     ...queueItem,
     creationTime: '',
@@ -72,12 +100,19 @@ export function formatQueueItem(queueItem) {
   return filteredQueueItem;
 }
 
-export function handleError({error, expectedToThrow, expectedErrorMessage, expectedErrorStatus}) {
+interface HandleErrorParams {
+  error: any;
+  expectedToThrow: boolean;
+  expectedErrorMessage: string;
+  expectedErrorStatus: string;
+}
+
+export function handleError(params: HandleErrorParams) {
+  const {error, expectedToThrow, expectedErrorMessage, expectedErrorStatus} = params;
   debug(error);
   if (expectedToThrow) {
     debug('OK. Expected to throw');
     debug(JSON.stringify(error));
-    // eslint-disable-next-line max-lines
     if (expectedErrorMessage !== '' || expectedErrorStatus !== '') {
       const errorMessage = error.message || error.payload.message || error.payload || '';
       debug(errorMessage);
@@ -92,12 +127,11 @@ export function handleError({error, expectedToThrow, expectedErrorMessage, expec
   throw error;
 }
 
-export function streamToString(stream) {
-  const chunks = [];
+export function streamToString(stream: Readable): Promise<string> {
+  const chunks: Buffer[] = [];
   return new Promise((resolve, reject) => {
-    // eslint-disable-next-line functional/immutable-data
-    stream.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
-    stream.on('error', (err) => reject(err));
+    stream.on('data', (chunk: Buffer) => chunks.push(Buffer.from(chunk)));
+    stream.on('error', (err: unknown) => reject(err));
     stream.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
   });
 }