@natlibfi/melinda-rest-api-commons 6.2.0-alpha.1 → 6.2.0-alpha.3

package/package.json

@@ -13,7 +13,7 @@
     "url": "https://github.com/NatLibFi/melinda-rest-api-commons"
   },
   "license": "MIT",
-  "version": "6.2.0-alpha.1",
+  "version": "6.2.0-alpha.3",
   "main": "./dist/index.js",
   "type": "module",
   "engines": {
@@ -42,6 +42,7 @@
     "@natlibfi/marc-record-validate": "^9.0.2",
     "@natlibfi/marc-record-validators-melinda": "^13.0.6",
     "@natlibfi/melinda-commons": "^16.0.0",
+    "@types/node": "^25.9.9",
     "amqplib": "^2.2.0",
     "debug": "^4.4.3",
     "http-status": "^2.1.0",
@@ -53,7 +54,6 @@
     "@natlibfi/fixura-mongo": "^4.0.2",
     "@types/debug": "^4.1.13",
     "@types/http-status": "^0.2.30",
-    "@types/node": "^25.9.9",
     "cross-env": "^10.1.0",
     "eslint": "^10.12.0",
     "jiti": "^2.7.0",

package/test/amqp-error-branches.test.ts

@@ -555,13 +555,11 @@ test('healthCheck error while running rethrows into the un-awaited loop promise'
   assert.ok(stdout.endsWith('OK'), `expected child output to end with OK, got: ${stdout}`);
 });
 
-test('broker loss (error + close events) logs the error and close cancels the health check', async () => {
-  // Failure-path listeners on the amqplib connection/channel:
-  // - 'error' must only log: without a handler an unhandled EventEmitter
-  //   'error' would become an uncaughtException, and the error alone must
-  //   NOT stop the loop (the fast-fail contract is unchanged)
-  // - 'close' must cancel the health check loop so no iterations keep
-  //   running on a dead link (matters for runHealthCheck: false consumers)
+test('graceful shutdown: expected close events cancel the loop without a fatal signal', async () => {
+  // closeChannel/closeConnection set shuttingDown before the intentional
+  // close, so the 'close' events amqplib emits for the expected close cancel
+  // the health check loop instead of leaving it to fail on a closed channel.
+  // The whole shutdown must not leak the fatal rejection.
   const handlers: Record<string, ((...args: unknown[]) => void)[]> = {};
   const makeOn = (target: string) => (event: string, handler: (...args: unknown[]) => void) => {
     const key = `${target}:${event}`;
@@ -569,41 +567,132 @@ test('broker loss (error + close events) logs the error and close cancels the he
     list.push(handler);
     return {off: () => {}};
   };
+  let closed = false;
   let healthCheckCalls = 0;
   const channel = makeChannel({
     on: makeOn('channel'),
     assertQueue: async (name: string) => {
       if (name === 'HEALTHCHECK') {
         healthCheckCalls += 1;
+        if (closed) {
+          throw new Error('channel closed');
+        }
       }
       return {messageCount: 0};
+    },
+    close: async () => {
+      closed = true;
     }
   });
-  await createAmqp(DUMMY_URL, true, {
-    connection: {createChannel: async () => channel, close: async () => {}, on: makeOn('connection')},
-    channel
+  const unhandled: unknown[] = [];
+  const onUnhandledRejection = (error: unknown) => unhandled.push(error);
+  process.on('unhandledRejection', onUnhandledRejection);
+  try {
+    const amqpOperator = await createAmqp(DUMMY_URL, true, {
+      connection: {createChannel: async () => channel, close: async () => {}, on: makeOn('connection')},
+      channel
+    });
+    await new Promise((resolve) => setTimeout(resolve, 350));
+    assert.ok(healthCheckCalls > 0, 'health check should have run before close');
+    await amqpOperator.closeChannel();
+    // the expected close events: they must not change the already-cancelled
+    // state into a fatal one
+    for (const handler of handlers['channel:close'] ?? []) handler();
+    for (const handler of handlers['connection:close'] ?? []) handler();
+    // wait longer than the 200 ms loop interval
+    await new Promise((resolve) => setTimeout(resolve, 500));
+  } finally {
+    process.off('unhandledRejection', onUnhandledRejection);
+  }
+  assert.deepStrictEqual(unhandled, [], 'no unhandled rejections on graceful shutdown');
+});
+
+test('broker loss (error + close events) preserves the healthCheck fast-fail', async () => {
+  // Failure-path listeners on the amqplib connection/channel:
+  // - 'error' must only log: without a handler an unhandled EventEmitter
+  //   'error' would become an uncaughtException
+  // - an UNEXPECTED 'close' (link death / broker loss, shuttingDown false)
+  //   must NOT cancel the health check loop: the loop keeps failing on the
+  //   dead broker and the error escapes as an unhandled rejection - the
+  //   documented fast-fail (exit(1)). Only an intentional
+  //   closeChannel/closeConnection cancels the loop and suppresses the
+  //   rethrow.
+  // The escape is verified in a child node process that installs its own
+  // unhandledRejection handler before triggering the loss (the node test
+  // runner fails a test on any in-process unhandled rejection).
+  const script = `
+    import createAmqp from '${AMQP_MODULE_PATH}';
+    const handlers = {};
+    const makeOn = (target) => (event, handler) => {
+      const key = target + ':' + event;
+      const list = handlers[key] ?? (handlers[key] = []);
+      list.push(handler);
+      return {off: () => {}};
+    };
+    let brokerLost = false;
+    let healthCheckCalls = 0;
+    const channel = {
+      assertQueue: /** @param {*} name */ async (name) => {
+        if (name === 'HEALTHCHECK') {
+          healthCheckCalls += 1;
+          if (brokerLost) {
+            throw new Error('broker lost');
+          }
+        }
+        return {messageCount: 0};
+      },
+      checkQueue: async () => ({messageCount: 0}),
+      get: async () => false,
+      ack: () => {},
+      nack: () => {},
+      purgeQueue: async () => {},
+      close: async () => {},
+      sendToQueue: async () => {},
+      on: makeOn('channel')
+    };
+    const captured = [];
+    process.on('unhandledRejection', (err) => captured.push(err));
+    await createAmqp('amqp://stub:5672/', true, {
+      connection: {createChannel: async () => channel, close: async () => {}, on: makeOn('connection')},
+      channel
+    });
+    // all four listeners must be attached (connection + channel, error + close)
+    const attached = Object.keys(handlers).sort();
+    const listenersOk = JSON.stringify(attached) === JSON.stringify(['channel:close', 'channel:error', 'connection:close', 'connection:error']);
+    // let the loop run a couple of iterations, then simulate broker loss the
+    // way amqplib signals it: an 'error' event followed by an unexpected
+    // 'close' (no closeChannel/closeConnection was called)
+    await new Promise((resolve) => setTimeout(resolve, 350));
+    for (const handler of handlers['channel:error'] ?? []) handler(new Error('socket lost'));
+    for (const handler of handlers['connection:error'] ?? []) handler(new Error('socket lost'));
+    for (const handler of handlers['channel:close'] ?? []) handler();
+    for (const handler of handlers['connection:close'] ?? []) handler();
+    // the unexpected close must NOT cancel the loop: it keeps running on the
+    // still-healthy stub (wait longer than the 200 ms loop interval)
+    const callsAfterClose = healthCheckCalls;
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    const keptRunning = healthCheckCalls > callsAfterClose;
+    // now the broker is actually gone: the next failed assert must escape as
+    // the unhandled rejection (the documented fast-fail)
+    brokerLost = true;
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    const ok =
+      listenersOk &&
+      healthCheckCalls > 0 &&
+      keptRunning &&
+      captured.length === 1 &&
+      /broker lost/.test(String(captured[0] && captured[0].message));
+    process.stdout.write(ok ? 'OK' : 'FAIL:' + JSON.stringify({attached, healthCheckCalls, rejections: captured.map((e) => String(e && e.message))}));
+    process.exit(ok ? 0 : 1);
+  `;
+  const {code, stdout} = await new Promise<{code: number | string, stdout: string}>((resolve) => {
+    const child = execFile(process.execPath, ['--input-type=module', '-e', script], (err, out) => {
+      resolve({code: err ? (err.code ?? 1) : 0, stdout: out ?? ''});
+    });
+    void child;
   });
-  // all four listeners must be attached (connection + channel, error + close)
-  assert.deepStrictEqual(Object.keys(handlers).sort(), [
-    'channel:close',
-    'channel:error',
-    'connection:close',
-    'connection:error'
-  ]);
-  // let the loop run a couple of iterations, then simulate broker loss the
-  // way amqplib signals it: an 'error' event followed by 'close'
-  await new Promise((resolve) => setTimeout(resolve, 350));
-  for (const handler of handlers['channel:error'] ?? []) handler(new Error('socket lost'));
-  for (const handler of handlers['connection:error'] ?? []) handler(new Error('socket lost'));
-  // the 'error' events alone must not cancel the loop
-  const callsAfterError = healthCheckCalls;
-  await new Promise((resolve) => setTimeout(resolve, 500));
-  assert.ok(healthCheckCalls > 0, 'health check should have run before the broker loss');
-  assert.ok(healthCheckCalls > callsAfterError, 'health check keeps running after the error events');
-  for (const handler of handlers['channel:close'] ?? []) handler();
-  for (const handler of handlers['connection:close'] ?? []) handler();
-  const callsAfterClose = healthCheckCalls;
-  // wait longer than the 200 ms loop interval - no further health checks may fire
-  await new Promise((resolve) => setTimeout(resolve, 500));
-  assert.equal(healthCheckCalls, callsAfterClose, 'no health checks after the close events');
+  assert.equal(code, 0, `child process output: ${stdout}`);
+  // the error listeners and handleAmqpErrors log to stdout before the escape,
+  // so only the tail matters
+  assert.ok(stdout.endsWith('OK'), `expected child output to end with OK, got: ${stdout}`);
 });

package/test/mongo-add-blob-size.test.ts

@@ -8,6 +8,7 @@ import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils.
 
 
 let mongoFixtures: any;
+const openedOperators: any[] = [];
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:add-blob-size:test');
 
 generateTests({
@@ -34,6 +35,10 @@ generateTests({
     },
     after: async () => {
       //debug(`<< After`);
+      // close the operators the tests opened (one per test) before the server
+      for (const op of openedOperators) {
+        await op.close();
+      }
       await mongoFixtures.close();
     }
   }
@@ -61,6 +66,7 @@ async function callback(callbackParams: Record<string, any>) {
   } = callbackParams;
 
   const mongoOperator = await getMongoOperator(mongoFixtures);
+  openedOperators.push(mongoOperator);
   const expectedResult = await getFixture('expectedResult.json');
 
   await doPreFillDb(preFillDb);

package/test/mongo-check-and-check-state.test.ts

@@ -8,6 +8,7 @@ import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils.
 
 
 let mongoFixtures: any;
+const openedOperators: any[] = [];
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:test');
 
 generateTests({
@@ -34,6 +35,10 @@ generateTests({
     },
     after: async () => {
       //debug(`<< After`);
+      // close the operators the tests opened (one per test) before the server
+      for (const op of openedOperators) {
+        await op.close();
+      }
       await mongoFixtures.close();
     }
   }
@@ -62,6 +67,7 @@ async function callback(callbackParams: Record<string, any>) {
   } = callbackParams;
 
   const mongoOperator = await getMongoOperator(mongoFixtures);
+  openedOperators.push(mongoOperator);
   const expectedResult = await getFixture('expectedResult.json');
 
   await doPreFillDb(preFillDb);

package/test/mongo-check-and-set-import-job-state.test.ts

@@ -7,6 +7,7 @@ import createDebugLogger from 'debug';
 import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils.ts';
 
 let mongoFixtures: any;
+const openedOperators: any[] = [];
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:check-and-set-import-job-state-test');
 
 generateTests({
@@ -33,6 +34,10 @@ generateTests({
     },
     after: async () => {
       //debug(`<< After`);
+      // close the operators the tests opened (one per test) before the server
+      for (const op of openedOperators) {
+        await op.close();
+      }
       await mongoFixtures.close();
     }
   }
@@ -61,6 +66,7 @@ async function callback(callbackParams: Record<string, any>) {
   } = callbackParams;
 
   const mongoOperator = await getMongoOperator(mongoFixtures);
+  openedOperators.push(mongoOperator);
   const expectedResult = await getFixture('expectedResult.json');
 
   await doPreFillDb(preFillDb);

package/test/mongo-check-timeout.test.ts

@@ -8,6 +8,7 @@ import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils.
 
 
 let mongoFixtures: any;
+const openedOperators: any[] = [];
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:check-timeout:test');
 
 generateTests({
@@ -34,6 +35,10 @@ generateTests({
     },
     after: async () => {
       //debug(`<< After`);
+      // close the operators the tests opened (one per test) before the server
+      for (const op of openedOperators) {
+        await op.close();
+      }
       await mongoFixtures.close();
     }
   }
@@ -62,6 +67,7 @@ async function callback(callbackParams: Record<string, any>) {
   } = callbackParams;
 
   const mongoOperator = await getMongoOperator(mongoFixtures);
+  openedOperators.push(mongoOperator);
   const expectedResult = await getFixture('expectedResult.json');
 
   await doPreFillDb(preFillDb);

package/test/mongo-create-bulk.test.ts

@@ -6,6 +6,7 @@ import createDebugLogger from 'debug';
 import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils.ts';
 
 let mongoFixtures: any;
+const openedOperators: any[] = [];
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:test:create-bulk');
 
 generateTests({
@@ -32,6 +33,10 @@ generateTests({
     },
     after: async () => {
       //debug(`<< After`);
+      // close the operators the tests opened (one per test) before the server
+      for (const op of openedOperators) {
+        await op.close();
+      }
       await mongoFixtures.close();
     }
   }
@@ -59,6 +64,7 @@ async function callback(callbackParams: Record<string, any>) {
   } = callbackParams;
 
   const mongoOperator = await getMongoOperator(mongoFixtures);
+  openedOperators.push(mongoOperator);
   const expectedResult = await getFixture('expectedResult.json');
 
   await doPreFillDb(preFillDb);

package/test/mongo-create-prio.test.ts

@@ -7,6 +7,7 @@ import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils.
 // import {handleError, compareToFirstDbEntry, compareToDbEntry, formatQueueItem, streamToString} from './testUtils.js';
 
 let mongoFixtures: any;
+const openedOperators: any[] = [];
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:create-prio-test');
 
 generateTests({
@@ -33,6 +34,10 @@ generateTests({
     },
     after: async () => {
       //debug(`<< After`);
+      // close the operators the tests opened (one per test) before the server
+      for (const op of openedOperators) {
+        await op.close();
+      }
       await mongoFixtures.close();
     }
   }
@@ -58,6 +63,7 @@ async function callback(callbackParams: Record<string, any>) {
   } = callbackParams;
 
   const mongoOperator = await getMongoOperator(mongoFixtures);
+  openedOperators.push(mongoOperator);
   const expectedResult = await getFixture('expectedResult.json');
 
   await doPreFillDb(preFillDb);

package/test/mongo-error-branches.test.ts

@@ -1,5 +1,5 @@
 import assert from 'node:assert';
-import {test} from 'node:test';
+import {test, after} from 'node:test';
 import {Readable, PassThrough} from 'node:stream';
 import httpStatus from 'http-status';
 import {MongoDriverError} from 'mongodb';
@@ -9,6 +9,9 @@ import createMongoLog from '../src/mongoLog.ts';
 
 const DUMMY_URI = 'mongodb://stub:27017/rest-api';
 const COLLECTION = 'foobar';
+// every test creates its own (stubbed) operators; close them all at the
+// end - close is a no-op for stubbed factories, which is the point
+const stubOperators: any[] = [];
 
 // the deps seam takes unknown-typed dependencies, so plain stub objects
 // are fine to inject (the driver types are never exercised here)
@@ -35,7 +38,9 @@ function makeGridFSBucket(overrides: Record<string, any> = {}) {
  * @param deps the injected stub operator/gridFSBucket
  */
 async function makeMongo(deps: Record<string, any>) {
-  return createMongo(DUMMY_URI, COLLECTION, 'rest-api', deps);
+  const mongo = await createMongo(DUMMY_URI, COLLECTION, 'rest-api', deps);
+  stubOperators.push(mongo);
+  return mongo;
 }
 
 // The 400-guard tests pass intentionally malformed inputs (non-string
@@ -214,6 +219,119 @@ test('checkTimeOut returns false (no crash) when the queueItem does not exist',
   assert.equal(result, false);
 });
 
+// checkAndSetState / checkAndSetImportJobState must report a missing item
+// as 'unchanged' (with a null queueItem) — not as a timeout
+
+test('checkAndSetState returns {status: "unchanged", queueItem: null} when the queueItem does not exist', async () => {
+  const mongo = await makeMongo({
+    operator: makeOperator({findOne: async () => null}),
+    gridFSBucket: makeGridFSBucket()
+  });
+  const result = await mongo.checkAndSetState({correlationId: 'NOPE', state: 'VALIDATING'});
+  assert.deepStrictEqual(result, {status: 'unchanged', queueItem: null});
+});
+
+test('checkAndSetImportJobState returns {status: "unchanged", queueItem: null} when the queueItem does not exist', async () => {
+  const mongo = await makeMongo({
+    operator: makeOperator({findOne: async () => null}),
+    gridFSBucket: makeGridFSBucket()
+  });
+  const result = await mongo.checkAndSetImportJobState({correlationId: 'NOPE', operation: 'FIX', importJobState: 'DONE'});
+  assert.deepStrictEqual(result, {status: 'unchanged', queueItem: null});
+});
+
+// a pre-existing ABORT item must be reported as 'unchanged' (not
+// 'timeout', which is reserved for items aborted by checkTimeOut in this
+// call) and the document must be left untouched
+
+test('checkAndSetState reports a pre-existing ABORT as "unchanged" without writing', async () => {
+  const doc = {correlationId: 'FOO', queueItemState: 'ABORT', errorStatus: 408, errorMessage: 'Timeout in VALIDATING'};
+  const writes: unknown[] = [];
+  const mongo = await makeMongo({
+    operator: makeOperator({
+      findOne: async () => doc,
+      findOneAndUpdate: async (filter: unknown, update: unknown) => {
+        writes.push({filter, update});
+        return doc;
+      }
+    }),
+    gridFSBucket: makeGridFSBucket()
+  });
+  const result = await mongo.checkAndSetState({correlationId: 'FOO', state: 'VALIDATING'});
+  assert.deepStrictEqual(result, {status: 'unchanged', queueItem: doc});
+  assert.deepStrictEqual(writes, []);
+});
+
+test('checkAndSetImportJobState reports a pre-existing ABORT as "unchanged" without writing', async () => {
+  const doc = {correlationId: 'FOO', queueItemState: 'ABORT', errorStatus: 408, errorMessage: 'Timeout in VALIDATING'};
+  const writes: unknown[] = [];
+  const mongo = await makeMongo({
+    operator: makeOperator({
+      findOne: async () => doc,
+      findOneAndUpdate: async (filter: unknown, update: unknown) => {
+        writes.push({filter, update});
+        return doc;
+      }
+    }),
+    gridFSBucket: makeGridFSBucket()
+  });
+  const result = await mongo.checkAndSetImportJobState({correlationId: 'FOO', operation: 'FIX', importJobState: 'DONE'});
+  assert.deepStrictEqual(result, {status: 'unchanged', queueItem: doc});
+  assert.deepStrictEqual(writes, []);
+});
+
+// Known pre-existing concurrency outcome, pinned here as a regression test
+// (a future redesign intentionally changes it): the document is VALIDATING,
+// a concurrent ABORT request comes in and aborts the item, then a second
+// ABORT request comes in. If that second request's pre-read still sees
+// VALIDATING (the first request's abort lands between the pre-read and the
+// internal timeout check), checkTimeOut finds the already-ABORTED document,
+// declines to act, and the post-hoc read still sees ABORT — the second
+// ABORT is reported as 'timeout' (not 'unchanged')
+test('checkAndSetState reports a second concurrent ABORT as "timeout" when the first ABORT lands after its pre-read', async () => {
+  const validDoc = {correlationId: 'FOO', queueItemState: 'VALIDATING'};
+  const abortDoc = {correlationId: 'FOO', queueItemState: 'ABORT', errorStatus: 408, errorMessage: 'Timeout in VALIDATING'};
+  // read order for the second ABORT request: the pre-read still sees
+  // VALIDATING, then the first request's abort lands, so both the timeout
+  // check read and the post-hoc read see ABORT
+  const reads = [validDoc, abortDoc, abortDoc];
+  const writes: unknown[] = [];
+  const mongo = await makeMongo({
+    operator: makeOperator({
+      findOne: async () => reads.shift() ?? abortDoc,
+      findOneAndUpdate: async (filter: unknown, update: unknown) => {
+        writes.push({filter, update});
+        return abortDoc;
+      }
+    }),
+    gridFSBucket: makeGridFSBucket()
+  });
+  const result = await mongo.checkAndSetState({correlationId: 'FOO', state: 'ABORT'});
+  assert.deepStrictEqual(result, {status: 'timeout', queueItem: abortDoc});
+  assert.deepStrictEqual(writes, []);
+});
+
+// a pre-existing DONE item is terminal too (like ABORT/ERROR) and must be
+// reported as 'unchanged' without touching the document
+
+test('checkAndSetState reports a pre-existing DONE as "unchanged" without writing', async () => {
+  const doc = {correlationId: 'FOO', queueItemState: 'DONE'};
+  const writes: unknown[] = [];
+  const mongo = await makeMongo({
+    operator: makeOperator({
+      findOne: async () => doc,
+      findOneAndUpdate: async (filter: unknown, update: unknown) => {
+        writes.push({filter, update});
+        return doc;
+      }
+    }),
+    gridFSBucket: makeGridFSBucket()
+  });
+  const result = await mongo.checkAndSetState({correlationId: 'FOO', state: 'VALIDATING'});
+  assert.deepStrictEqual(result, {status: 'unchanged', queueItem: doc});
+  assert.deepStrictEqual(writes, []);
+});
+
 test('setOperation rejects with ApiError 404 for a non-matching correlationId', async () => {
   const mongo = await makeMongo({
     operator: makeOperator({findOne: async () => null}),
@@ -750,9 +868,17 @@ function makeLogCollection(overrides: Record<string, any> = {}) {
  * @param deps the injected stub collection
  */
 async function makeMongoLog(deps: Record<string, any>) {
-  return createMongoLog(DUMMY_URI, 'rest-api', deps);
+  const mongoLog = await createMongoLog(DUMMY_URI, 'rest-api', deps);
+  stubOperators.push(mongoLog);
+  return mongoLog;
 }
 
+after(async () => {
+  for (const op of stubOperators) {
+    await op.close();
+  }
+});
+
 function mongoErrored500(text: string) {
   return (error: unknown) => {
     assert.ok(error instanceof ApiError);

package/test/mongo-get-one.test.ts

@@ -8,6 +8,7 @@ import {getMongoOperator, handleError} from './testUtils.ts';
 
 
 let mongoFixtures: any;
+const openedOperators: any[] = [];
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:get-one:test');
 
 generateTests({
@@ -34,6 +35,10 @@ generateTests({
     },
     after: async () => {
       //debug(`<< After`);
+      // close the operators the tests opened (one per test) before the server
+      for (const op of openedOperators) {
+        await op.close();
+      }
       await mongoFixtures.close();
     }
   }
@@ -60,6 +65,7 @@ async function callback(callbackParams: Record<string, any>) {
   } = callbackParams;
 
   const mongoOperator = await getMongoOperator(mongoFixtures);
+  openedOperators.push(mongoOperator);
   //const expectedResult = await getFixture('expectedResult.json');
 
   await doPreFillDb(preFillDb);

package/test/mongo-get-stream.test.ts

@@ -7,6 +7,7 @@ import createDebugLogger from 'debug';
 import {getMongoOperator, handleError, streamToString} from './testUtils.ts';
 
 let mongoFixtures: any;
+const openedOperators: any[] = [];
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:get-stream:test');
 
 generateTests({
@@ -33,6 +34,10 @@ generateTests({
     },
     after: async () => {
       //debug(`<< After`);
+      // close the operators the tests opened (one per test) before the server
+      for (const op of openedOperators) {
+        await op.close();
+      }
       await mongoFixtures.close();
     }
   }
@@ -60,6 +65,7 @@ async function callback(callbackParams: Record<string, any>) {
   } = callbackParams;
 
   const mongoOperator = await getMongoOperator(mongoFixtures);
+  openedOperators.push(mongoOperator);
   //const expectedResult = await getFixture('expectedResult.json');
 
   await doPreFillDb(preFillDb);

package/test/mongo-push-ids.test.ts

@@ -7,6 +7,7 @@ import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils.
 
 
 let mongoFixtures: any;
+const openedOperators: any[] = [];
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:push-ids:test');
 
 generateTests({
@@ -33,6 +34,10 @@ generateTests({
     },
     after: async () => {
       //debug(`<< After`);
+      // close the operators the tests opened (one per test) before the server
+      for (const op of openedOperators) {
+        await op.close();
+      }
       await mongoFixtures.close();
     }
   }
@@ -59,6 +64,7 @@ async function callback(callbackParams: Record<string, any>) {
   } = callbackParams;
 
   const mongoOperator = await getMongoOperator(mongoFixtures);
+  openedOperators.push(mongoOperator);
   const expectedResult = await getFixture('expectedResult.json');
 
   await doPreFillDb(preFillDb);

package/test/mongo-push-messages.test.ts

@@ -7,6 +7,7 @@ import createDebugLogger from 'debug';
 import {getMongoOperator, handleError, compareToFirstDbEntry} from './testUtils.ts';
 
 let mongoFixtures: any;
+const openedOperators: any[] = [];
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:push-messages:test');
 
 generateTests({
@@ -33,6 +34,10 @@ generateTests({
     },
     after: async () => {
       //debug(`<< After`);
+      // close the operators the tests opened (one per test) before the server
+      for (const op of openedOperators) {
+        await op.close();
+      }
       await mongoFixtures.close();
     }
   }
@@ -59,6 +64,7 @@ async function callback(callbackParams: Record<string, any>) {
   } = callbackParams;
 
   const mongoOperator = await getMongoOperator(mongoFixtures);
+  openedOperators.push(mongoOperator);
   const expectedResult = await getFixture('expectedResult.json');
 
   await doPreFillDb(preFillDb);

package/test/mongo-query-by-id.test.ts

@@ -8,6 +8,7 @@ import {getMongoOperator, handleError, compareToDbEntry, formatQueueItem} from '
 
 
 let mongoFixtures: any;
+const openedOperators: any[] = [];
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons/mongo:query-by-id:test');
 
 generateTests({
@@ -34,6 +35,10 @@ generateTests({
     },
     after: async () => {
       //debug(`<< After`);
+      // close the operators the tests opened (one per test) before the server
+      for (const op of openedOperators) {
+        await op.close();
+      }
       await mongoFixtures.close();
     }
   }
@@ -63,6 +68,7 @@ async function callback(callbackParams: Record<string, any>) {
   } = callbackParams;
 
   const mongoOperator = await getMongoOperator(mongoFixtures);
+  openedOperators.push(mongoOperator);
   const expectedResult = await getFixture('expectedResult.json');
 
   await doPreFillDb(preFillDb);