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

package/tests/mongo-get-stream.test.js

@@ -90,7 +90,10 @@ async function callback({
       }
       //const {correlationId} = params;
 
-      const opResult = mongoOperator.getStream(params);
+      // getStream is now async (it pre-checks file existence and
+      // throws 404 for a missing file instead of returning a stream that
+      // emits an unhandled 'error' event)
+      const opResult = await mongoOperator.getStream(params);
       const opResultString = await streamToString(opResult);
 
       if (contentStream) {

package/tests/mongo-read-content.test.js

@@ -69,6 +69,16 @@ async function callback({
   async function doPreFillDb(preFillDb) {
     if (preFillDb) {
       await mongoFixtures.populate(getFixture('dbContents.json'));
+      // optional gridFSFiles.json uploads GridFS files (filename -> content)
+      let gridFSFiles = undefined;
+      try {
+        gridFSFiles = getFixture('gridFSFiles.json');
+      } catch {
+        // no GridFS files for this fixture
+      }
+      if (gridFSFiles) {
+        await mongoFixtures.populateFiles(gridFSFiles);
+      }
       return;
     }
     return;

package/tests/mongoLog-protect.test.js

@@ -0,0 +1,181 @@
+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.js';
+
+let mongoFixtures; // eslint-disable-line functional/no-let
+let mongoLogOperator; // eslint-disable-line functional/no-let
+
+async function initMongofixtures() {
+  mongoFixtures = await mongoFixturesFactory({
+    rootPath: [import.meta.dirname, '..', 'test-fixtures', 'mongoLog'],
+    gridFS: {bucketName: 'blobs'},
+    useObjectId: true,
+    format: {
+      logs: {
+        creationTime: v => new Date(v),
+        modificationTime: v => new Date(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 => 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 => 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 => doc.correlationId === correlationId);
+  assert.equal(own.length, 2);
+  assert.ok(own.every(doc => 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.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.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.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 => 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/tests/mongoLog.test.js

@@ -1,10 +1,11 @@
 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.js';
 
-let mongoFixtures; // eslint-disable-line functional/no-let
+let mongoFixtures;
 
 generateTests({
   callback,
@@ -32,9 +33,16 @@ async function initMongofixtures() {
     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: {
-      creationTime: v => new Date(v),
-      modificationTime: v => new Date(v)
+      logs: {
+        creationTime: v => new Date(v),
+        modificationTime: v => new Date(v)
+      }
     }
   });
 }
@@ -43,11 +51,40 @@ async function callback({
   getFixture,
   functionName,
   params,
-  preFillDb = false
+  preFillDb = false,
+  expectError = false,
+  expectedErrorStatus = 500
 }) {
   const mongoUri = await mongoFixtures.getUri();
   const mongoLogOperator = await createMongoLogOperator(mongoUri, '');
-  const expectedResult = await getFixture('expectedResult.json');
+  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) {
@@ -71,7 +108,7 @@ async function callback({
     const result = await mongoLogOperator.getExpandedListOfLogs(params);
     // console.log(result); // eslint-disable-line
 
-    return assert.deepEqual(result, expectedResult);
+    return assert.deepEqual(normalizeDates(result), expectedResult);
   }
 
   if (functionName === 'getListOfLogs') {
@@ -79,6 +116,76 @@ async function callback({
     // 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) {
+  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;
+  });
+}
+