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

package/{tests/amqp.tests.localtest.js → test/amqp.tests.localtest.ts}

@@ -3,8 +3,11 @@ import createDebugLogger from 'debug';
 import {promisify} from 'util';
 import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen';
+import type {CallbackArgs} from '@natlibfi/fixugen';
 import {Error as ApiError} from '@natlibfi/melinda-commons';
-import {amqpFactory} from '../src/index.js';
+import type {GetMessage, Message} from 'amqplib';
+import {amqpFactory} from '../src/index.ts';
+import type {AmqpOperator, QueueItemMessagePayload, QueueItemRecordPayload, SendToQueueParams} from '../src/amqp.ts';
 
 const setTimeoutPromise = promisify(setTimeout);
 const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons:amqp:test');
@@ -18,8 +21,7 @@ const testData = {
 
 debug(`Testing amqp against a local AMQP instance - we'll need some kind of mockup for this`);
 const amqpUrl = 'amqp://127.0.0.1:5672/';
-// eslint-disable-next-line functional/no-let
-let amqpOperator;
+let amqpOperator: AmqpOperator;
 
 generateTests({
   callback,
@@ -48,8 +50,15 @@ generateTests({
   }
 });
 
-// eslint-disable-next-line max-statements
-async function callback({
+/**
+ * One fixture case. See the fixture metadata files in test-fixtures/amqp
+ * for the possible keys (getFixture, expectToFail, expectedErrorStatus,
+ * ackMessages, nackMessages, checkNextMessage, checkQueueStyle, queue,
+ * sentToQueue, expectedMessageCount, removeQueue, expectedErrorMessage,
+ * expectApiError, expectFalseCheckResult).
+ */
+async function callback(callbackParams: CallbackArgs) {
+  const {
   getFixture,
   expectToFail = false,
   expectedErrorStatus = '',
@@ -57,14 +66,16 @@ async function callback({
   nackMessages = false,
   checkNextMessage = false,
   checkQueueStyle = false,
-  queue = testData.queue,
+  queue: queueFromFixture = testData.queue,
   sentToQueue,
   expectedMessageCount,
   removeQueue = false,
   expectedErrorMessage = undefined,
   expectApiError = false,
   expectFalseCheckResult = false
-}) {
+  } = callbackParams;
+  // the fixture contract passes the queue name as a string
+  const queue = queueFromFixture as string;
   try {
     await sendMessagesToQueue();
 
@@ -79,10 +90,13 @@ async function callback({
     assert.equal(messageCount, expectedMessageCount);
 
     if (checkNextMessage) {
-      const {headers, records} = await queueCheckNextMessage();
+      const {headers, records} = (await queueCheckNextMessage()) as QueueItemRecordPayload;
       const nextMessage = {headers, records};
       const expectedNextMessage = getFixture('expectedMessage.json');
-      assert.equal(nextMessage, expectedNextMessage);
+      assert.deepStrictEqual(
+        JSON.parse(JSON.stringify(nextMessage)),
+        expectedNextMessage,
+      );
       return;
     }
 
@@ -94,15 +108,19 @@ async function callback({
     testErrors(error);
   }
 
-  function testErrors(error) {
+  /**
+   * @param error
+   */
+  function testErrors(error: unknown) {
     const isApiError = error instanceof ApiError;
     if (expectApiError) {
       assert.equal(isApiError, true);
       debug(`We expected and got an ApiError`);
-      assert.equal(error.status, expectedErrorStatus);
+      const apiError = error as ApiError;
+      assert.equal(apiError.status, expectedErrorStatus);
 
       if (expectedErrorMessage) {
-        assert.equal(error.payload, expectedErrorMessage);
+        assert.equal(apiError.payload, expectedErrorMessage);
         return;
       }
 
@@ -110,26 +128,26 @@ async function callback({
     }
     assert.equal(isApiError, false);
     debug(`We expected and got an non-ApiError`);
-    debug(`Error is a ${error.constructor.name}`);
+    const maybeError = error as Error;
+    debug(`Error is a ${maybeError.constructor.name}`);
   }
 
   function queueRemoval() {
     if (removeQueue) {
-      return amqpOperator.removeQueue(removeQueue);
+      return amqpOperator.removeQueue(removeQueue as string);
     }
 
     return;
   }
 
-  function queueCheckNextMessage() {
+  function queueCheckNextMessage(): Promise<QueueItemRecordPayload> | false {
     if (checkNextMessage) {
-      return amqpOperator.consumeOne(testData.queue, true);
+      return amqpOperator.consumeOne(testData.queue, true) as Promise<QueueItemRecordPayload>;
     }
 
     return false;
   }
 
-  // eslint-disable-next-line max-statements
   async function checkQueue() {
     debug(`checkQueueStyle: ${checkQueueStyle}`);
 
@@ -137,33 +155,29 @@ async function callback({
       const result = await amqpOperator.checkQueue({queue, style: 'one', toRecord: true, purge: false});
 
       if (expectFalseCheckResult) {
-        expect(result).to.eql(false);
+        assert.strictEqual(result, false);
         return;
       }
 
-      assert.equal(Object.hasOwn(result, 'headers'), true);
-      assert.equal(Object.hasOwn(result, 'records'), true);
-      assert.equal(Object.hasOwn(result, 'messages'), true);
-      assert.equal(result.records.length, 1);
-      assert.equal(result.messages.length, 1);
+      const recordResult = result as QueueItemRecordPayload;
+      assert.equal(Object.hasOwn(recordResult, 'headers'), true);
+      assert.equal(Object.hasOwn(recordResult, 'records'), true);
+      assert.equal(Object.hasOwn(recordResult, 'messages'), true);
+      assert.equal(recordResult.records.length, 1);
+      assert.equal(recordResult.messages.length, 1);
 
       return;
     }
 
     if (checkQueueStyle === 'oneNotRecord') {
       const result = await amqpOperator.checkQueue({queue, style: 'one', toRecord: false, purge: false});
-      const {fields} = result;
+      const {fields} = result as GetMessage;
 
       if (expectFalseCheckResult) {
-        expect(result).to.eql(false);
+        assert.strictEqual(result, false);
         return;
       }
 
-      assert.equal(Object.hasOwn(result, 'deliveryTag'), true);
-      assert.equal(Object.hasOwn(result, 'exchange'), true);
-      assert.equal(Object.hasOwn(result, 'messageCount'), true);
-      assert.equal(Object.hasOwn(result, 'redelivered'), true);
-      assert.equal(Object.hasOwn(result, 'routingKey'), true);
       assert.equal(typeof fields.deliveryTag, 'number');
       assert.equal(typeof fields.messageCount, 'number');
       assert.equal(typeof fields.redelivered, 'boolean');
@@ -176,17 +190,21 @@ async function callback({
       const result = await amqpOperator.checkQueue({queue, style: 'basic', toRecord: true, purge: false});
 
       if (expectFalseCheckResult) {
-        expect(result).to.eql(false);
+        assert.strictEqual(result, false);
         return;
       }
 
-      assert.equal(Object.hasOwn(result, 'headers'), true);
-      assert.equal(Object.hasOwn(result, 'records'), true);
-      assert.equal(Object.hasOwn(result, 'messages'), true);
-      assert.equal(result.records.length, 3);
-      assert.equal(result.messages.length, 3);
+      const recordResult = result as QueueItemRecordPayload;
+      assert.equal(Object.hasOwn(recordResult, 'headers'), true);
+      assert.equal(Object.hasOwn(recordResult, 'records'), true);
+      assert.equal(Object.hasOwn(recordResult, 'messages'), true);
+      assert.equal(recordResult.records.length, 3);
+      assert.equal(recordResult.messages.length, 3);
       const expectedResult = getFixture('expectedResult.json');
-      assert.deepStrictEqual(result.records, expectedResult);
+      assert.deepStrictEqual(
+        JSON.parse(JSON.stringify(recordResult.records)),
+        expectedResult,
+      );
 
       return;
     }
@@ -195,21 +213,17 @@ async function callback({
       const result = await amqpOperator.checkQueue({queue, style: 'basic', toRecord: false, purge: false});
 
       if (expectFalseCheckResult) {
-        expect(result).to.eql(false);
+        assert.strictEqual(result, false);
         return;
       }
 
-      assert.equal(Object.hasOwn(result, 'headers'), true);
-      assert.equal(Object.hasOwn(result, 'messages'), true);
-      assert.equal(result.messages.length, 3);
+      const messageResult = result as QueueItemMessagePayload;
+      assert.equal(Object.hasOwn(messageResult, 'headers'), true);
+      assert.equal(Object.hasOwn(messageResult, 'messages'), true);
+      assert.equal(messageResult.messages.length, 3);
 
-      const [{fields}] = result.messages;
-
-      assert.equal(Object.hasOwn(result, 'deliveryTag'), true);
-      assert.equal(Object.hasOwn(result, 'exchange'), true);
-      assert.equal(Object.hasOwn(result, 'messageCount'), true);
-      assert.equal(Object.hasOwn(result, 'redelivered'), true);
-      assert.equal(Object.hasOwn(result, 'routingKey'), true);
+      const [firstMessage] = messageResult.messages as [Message, ...Message[]];
+      const {fields} = firstMessage;
 
       assert.equal(typeof fields.deliveryTag, 'number');
       assert.equal(typeof fields.messageCount, 'number');
@@ -233,14 +247,14 @@ async function callback({
   async function ackOrNackMessages() {
     if (ackMessages) {
       const message = await amqpOperator.consumeOne(testData.queue, false);
-      await amqpOperator.ackMessages([message]);
+      await amqpOperator.ackMessages([message as GetMessage]);
 
       return setTimeoutPromise(10);
     }
 
     if (nackMessages) {
       const message = await amqpOperator.consumeOne(testData.queue, false);
-      await amqpOperator.nackMessages([message]);
+      await amqpOperator.nackMessages([message as GetMessage]);
 
       return setTimeoutPromise(10);
     }
@@ -250,7 +264,7 @@ async function callback({
 
   async function sendMessagesToQueue() {
     if (sentToQueue) {
-      const messages = getFixture('input.json');
+      const messages = getFixture('input.json') as SendToQueueParams[];
       // {queue, correlationId, headers, data}
 
       const promises = messages.map(message => amqpOperator.sendToQueue(message));
@@ -277,7 +291,7 @@ function testHeathCheck() {
       await testHealthCheckLoopErroring(amqpOperator2);
     } catch (error) {
       debug(error);
-      expect(error).to.eql('');
+      assert.strictEqual(error, '');
     } finally {
       amqpOperator2.closeConnection();
     }

package/{tests/helpers/conversion.test.js → test/helpers/conversion.test.ts}

@@ -1,12 +1,11 @@
-
-
 import assert from 'node:assert';
 import {describe, it} from 'node:test';
 import fixtureFactory from '@natlibfi/fixura';
 import {MarcRecord} from '@natlibfi/marc-record';
+import type {MarcRecordObject} from '@natlibfi/marc-record';
 import {Error as ConversionError} from '@natlibfi/melinda-commons';
-import createConversionService from '../../src/helpers/conversion.js';
-import {CONVERSION_FORMATS} from '../../src/constants.js';
+import createConversionService from '../../src/helpers/conversion.ts';
+import {CONVERSION_FORMATS} from '../../src/constants.ts';
 
 describe('services/conversion', () => {
   const {getFixture} = fixtureFactory({
@@ -20,11 +19,11 @@ describe('services/conversion', () => {
   });
   const conversionService = createConversionService();
 
-  const marcRecord = new MarcRecord(JSON.parse(getFixture({components: ['json1']})), {subfieldValues: false});
-  const marcXml = getFixture({components: ['marcxml1']});
-  const iso2709 = getFixture({components: ['iso2709_1']});
-  const json = getFixture({components: ['json1']});
-  const alephSeq = getFixture({components: ['aleph_sequential']});
+  const marcRecord = new MarcRecord(JSON.parse(getFixture({components: ['json1']}) as string) as MarcRecordObject, {subfieldValues: false});
+  const marcXml = getFixture({components: ['marcxml1']}) as string;
+  const iso2709 = getFixture({components: ['iso2709_1']}) as string;
+  const json = getFixture({components: ['json1']}) as string;
+  const alephSeq = getFixture({components: ['aleph_sequential']}) as string;
 
 
   describe('factory', () => {
@@ -38,11 +37,16 @@ describe('services/conversion', () => {
 
   describe('#serialize', () => {
     it('Should throw because of unsupported format', () => {
+      let threw = false;
       try {
-        conversionService.serialize();
+        // the undefined inputs are the point of this test: serialize must
+        // throw a ConversionError for an unsupported format, not a TypeError
+        conversionService.serialize(undefined as never, undefined as never);
       } catch (error) {
+        threw = true;
         assert(error instanceof ConversionError);
       }
+      assert.equal(threw, true);
     });
 
     it('Should serialize to MARCXML', () => {
@@ -65,15 +69,36 @@ describe('services/conversion', () => {
       assert.equal(data, alephSeq);
     });
 
+    it('Should rewrap a plain (non-ConversionError) serializer error into a ConversionError with 400', () => {
+      // a plain {} makes MARCXML.to throw a TypeError, which serialize must
+      // rewrap into a ConversionError 400 (not propagate the raw TypeError)
+      let threw = false;
+      try {
+        conversionService.serialize({} as never, CONVERSION_FORMATS.MARCXML);
+      } catch (error) {
+        threw = true;
+        assert(error instanceof ConversionError);
+        assert.equal(error.status, 400);
+        // the payload is a string here: 'Error while serializing record. ...'
+        assert.ok((error.payload as string).includes('Error while serializing record.'));
+      }
+      assert.equal(threw, true);
+    });
+
   });
 
   describe('#unserialize', () => {
     it('Should throw because of unsupported format', () => {
+      let threw = false;
       try {
-        conversionService.unserialize();
+        // the undefined inputs are the point of this test: unserialize must
+        // throw a ConversionError for an unsupported format, not a TypeError
+        conversionService.unserialize(undefined as never, undefined as never);
       } catch (error) {
+        threw = true;
         assert(error instanceof ConversionError);
       }
+      assert.equal(threw, true);
     });
 
     it('Should unserialize from MARCXML', async () => {
@@ -98,11 +123,14 @@ describe('services/conversion', () => {
 
 
     it('Should throw because the record could not be unserialized', () => {
+      let threw = false;
       try {
         conversionService.unserialize('', CONVERSION_FORMATS.JSON);
       } catch (error) {
+        threw = true;
         assert(error instanceof ConversionError);
       }
+      assert.equal(threw, true);
     });
   });
 });

package/test/helpers/fix-edge.test.ts

@@ -0,0 +1,201 @@
+// Edge-case tests for the MARC fix helpers.
+
+import assert from 'node:assert';
+import {test} from 'node:test';
+import {MarcRecord} from '@natlibfi/marc-record';
+import type {MarcField} from '@natlibfi/marc-record';
+import {fixRecord} from '../../src/helpers/fix.ts';
+import {BIB_STRIP_F884S_SETTINGS, BIB_F035_TO_SID} from '../../src/helpers/fix-constants.ts';
+
+// a Melinda f884 (tag 884, $5 MELINDA, $a + $g present) that
+// has NO $k subfield. findSource/findHash used to call `sfK.replace(...)` on
+// undefined and crash the whole fixRecord call. Now a missing $k is treated
+// as an empty string: the field gets NO_SOURCE (source) and the all-zero
+// sentinel (hash), and the merged date range is applied to its $g.
+test('fixRecord handles Melinda f884 without $k subfield without crashing', () => {
+  const record = new MarcRecord({
+    leader: '03085cam a22006858i 4500',
+    fields: [
+      {tag: '001', value: '000000001'},
+      {tag: '003', value: 'FI-MELINDA'},
+      {tag: '005', value: '20220818041047.0'},
+      {
+        // Melinda f884 WITHOUT $k
+        tag: '884',
+        ind1: ' ',
+        ind2: ' ',
+        subfields: [
+          {code: 'a', value: 'ONIX3 to MARC transformation'},
+          {code: 'g', value: '20220101'},
+          {code: '5', value: 'MELINDA'}
+        ]
+      },
+      {
+        // A second Melinda f884 with $k so that the
+        // "not enough Melinda f884s" early return does not trigger
+        tag: '884',
+        ind1: ' ',
+        ind2: ' ',
+        subfields: [
+          {code: 'a', value: 'ONIX3 to MARC transformation'},
+          {code: 'g', value: '20000718'},
+          {
+            code: 'k',
+            value: 'SRC_4:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
+          },
+          {code: '5', value: 'MELINDA'}
+        ]
+      }
+    ]
+  }, {subfieldValues: false});
+
+  // Fixed behaviour: fixRecord must not throw
+  const result = fixRecord(record, BIB_STRIP_F884S_SETTINGS);
+
+  // Both Melinda f884s survive (they are not identical, so uniq keeps both)
+  // these are data fields: mirrors the JSDoc baseline MarcField[] cast
+  const f884s = (result.fields as MarcField[]).filter((f) => f.tag === '884');
+  assert.equal(f884s.length, 2);
+
+  // The field WITHOUT $k still has its $a, $g and $5 MELINDA
+  const noK = f884s.find((f) => !f.subfields.some((s) => s.code === 'k'));
+  assert.ok(noK, 'field without $k should survive');
+  assert.deepEqual(
+    noK.subfields.map((s) => s.code).sort(),
+    ['5', 'a', 'g']
+  );
+  const gNoK = noK.subfields.find((s) => s.code === 'g')?.value;
+  const aNoK = noK.subfields.find((s) => s.code === 'a')?.value;
+  assert.equal(aNoK, 'ONIX3 to MARC transformation');
+  assert.equal(gNoK, '20220101');
+
+  // The field WITH $k keeps its $a, $g, $k and $5 MELINDA
+  const withK = f884s.find((f) => f.subfields.some((s) => s.code === 'k'));
+  assert.ok(withK, 'field with $k should survive');
+  assert.deepEqual(
+    withK.subfields.map((s) => s.code).sort(),
+    ['5', 'a', 'g', 'k']
+  );
+  assert.equal(withK.subfields.find((s) => s.code === 'g')?.value, '20000718');
+  assert.equal(withK.subfields.find((s) => s.code === 'k')?.value,
+    'SRC_4:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa');
+});
+
+// stripF884s early return: fewer than 2 Melinda f884s (0 or 1) means the
+// record is returned unchanged (the merge/uniq pipeline never runs).
+test('stripF884s returns the record unchanged when it has no Melinda f884s', () => {
+  const record = new MarcRecord({
+    leader: '03085cam a22006858i 4500',
+    fields: [
+      {tag: '001', value: '000000001'},
+      {tag: '035', ind1: ' ', ind2: ' ', subfields: [{code: 'a', value: '(FI-BTJ)12345'}]}
+    ]
+  }, {subfieldValues: false});
+
+  const result = fixRecord(record, BIB_STRIP_F884S_SETTINGS);
+  assert.deepStrictEqual(result, record.toObject());
+});
+
+test('stripF884s returns the record unchanged when it has a single Melinda f884', () => {
+  const record = new MarcRecord({
+    leader: '03085cam a22006858i 4500',
+    fields: [
+      {tag: '001', value: '000000001'},
+      {
+        // a single Melinda f884: fewer than 2, so the field must survive
+        // untouched (no date-range merge, no removeFields/insertFields)
+        tag: '884',
+        ind1: ' ',
+        ind2: ' ',
+        subfields: [
+          {code: 'a', value: 'ONIX3 to MARC transformation'},
+          {code: 'g', value: '20220101'},
+          {
+            code: 'k',
+            value: 'SRC_4:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
+          },
+          {code: '5', value: 'MELINDA'}
+        ]
+      }
+    ]
+  }, {subfieldValues: false});
+
+  const result = fixRecord(record, BIB_STRIP_F884S_SETTINGS);
+  assert.deepStrictEqual(result, record.toObject());
+});
+
+// generateMissingSIDs: an existing SID field is only counted when its $b is
+// in fSIDFilters AND it has a $c. Anything else maps to undefined and is
+// filtered out, so the SID is (re)generated from the f035.
+test('fixRecord ignores an existing SID field whose $b is not in fSIDFilters and generates the SID from the f035', () => {
+  const record = new MarcRecord({
+    leader: '03085cam a22006858i 4500',
+    fields: [
+      {tag: '001', value: '000000001'},
+      {tag: '035', ind1: ' ', ind2: ' ', subfields: [{code: 'a', value: '(FI-BTJ)12345'}]},
+      {
+        // $b 'FI-KV' is NOT in fSIDFilters -> the field must be ignored,
+        // so the f035 (FI-BTJ)12345 still yields a generated SID
+        tag: 'SID',
+        ind1: ' ',
+        ind2: ' ',
+        subfields: [
+          {code: 'c', value: '12345'},
+          {code: 'b', value: 'FI-KV'}
+        ]
+      }
+    ]
+  }, {subfieldValues: false});
+
+  const result = fixRecord(record, {generateMissingSIDs: BIB_F035_TO_SID});
+  // these are data fields: mirrors the JSDoc baseline MarcField[] cast
+  const sids = (result.fields as MarcField[]).filter((f) => f.tag === 'SID');
+  assert.equal(sids.length, 2);
+  const generated = sids.find((f) => f.subfields.some((s) => s.code === 'b' && s.value === 'FI-BTJ'));
+  assert.ok(generated, 'a new SID with $b FI-BTJ should have been generated');
+  assert.equal(generated.subfields.find((s) => s.code === 'c')?.value, '12345');
+});
+
+test('fixRecord ignores an existing SID field with a matching $b but missing $c and generates the SID from the f035', () => {
+  const record = new MarcRecord({
+    leader: '03085cam a22006858i 4500',
+    fields: [
+      {tag: '001', value: '000000001'},
+      {tag: '035', ind1: ' ', ind2: ' ', subfields: [{code: 'a', value: '(FI-BTJ)12345'}]},
+      {
+        // $b 'FI-BTJ' IS in fSIDFilters, but there is no $c -> the field
+        // must be ignored, so the f035 still yields a generated SID
+        tag: 'SID',
+        ind1: ' ',
+        ind2: ' ',
+        subfields: [
+          {code: 'b', value: 'FI-BTJ'}
+        ]
+      }
+    ]
+  }, {subfieldValues: false});
+
+  const result = fixRecord(record, {generateMissingSIDs: BIB_F035_TO_SID});
+  // these are data fields: mirrors the JSDoc baseline MarcField[] cast
+  const sids = (result.fields as MarcField[]).filter((f) => f.tag === 'SID');
+  assert.equal(sids.length, 2);
+  const generated = sids.find((f) => f.subfields.some((s) => s.code === 'c'));
+  assert.ok(generated, 'a generated SID with $c should exist');
+  assert.equal(generated.subfields.find((s) => s.code === 'b')?.value, 'FI-BTJ');
+  assert.equal(generated.subfields.find((s) => s.code === 'c')?.value, '12345');
+});
+
+test('fixRecord adds no SID when the f035 $a matches no f035Filter', () => {
+  const record = new MarcRecord({
+    leader: '03085cam a22006858i 4500',
+    fields: [
+      {tag: '001', value: '000000001'},
+      // $a does not match any f035Filter in BIB_F035_TO_SID, so
+      // f035ToSidInfo maps the field to undefined and nothing is generated
+      {tag: '035', ind1: ' ', ind2: ' ', subfields: [{code: 'a', value: '(NOT-IN-FILTERS)999'}]}
+    ]
+  }, {subfieldValues: false});
+
+  const result = fixRecord(record, {generateMissingSIDs: BIB_F035_TO_SID});
+  assert.equal(result.fields.filter((f) => f.tag === 'SID').length, 0);
+});

package/test/helpers/fix.test.ts

@@ -0,0 +1,65 @@
+import assert from 'node:assert';
+import createDebugLogger from 'debug';
+import {MarcRecord} from '@natlibfi/marc-record';
+import type {MarcRecordObject} from '@natlibfi/marc-record';
+import {READERS} from '@natlibfi/fixura';
+import generateTests, {type CallbackArgs} from '@natlibfi/fixugen';
+import {fixRecord} from '../../src/helpers/fix.ts';
+import * as fixSettings from '../../src/helpers/fix-constants.ts';
+import type {FixSettings} from '../../src/helpers/fix-constants.ts';
+// import inspect from 'util';
+
+const debug = createDebugLogger('@natlibfi/melinda-rest-api-commons:fix:test');
+const debugData = debug.extend('data');
+
+// the settings names usable via metadata.json
+type SettingsKey = 'BIB_FORMAT_SETTINGS' | 'BIB_PREVALIDATION_FIX_SETTINGS' | 'BIB_POSTMERGE_FIX_SETTINGS' | 'BIB_PREIMPORT_FIX_SETTINGS' | 'AUTNAME_PREIMPORT_FIX_SETTINGS' | 'BIB_HANDLE_TEMP_URNS_SETTINGS' | 'BIB_STRIP_F884S_SETTINGS' | 'BIB_STRIP_F984S_SETTINGS' | 'BIB_STRIP_MELINDA_TEMP_SUBFIELDS_SETTINGS';
+
+generateTests({
+  callback,
+  path: [import.meta.dirname, '..', '..', 'test-fixtures', 'fix'],
+  recurse: true,
+  useMetadataFile: true,
+  fixura: {
+    failWhenNotFound: false,
+    reader: READERS.JSON
+  }
+});
+
+function callback(callbackParams: CallbackArgs) {
+  const {getFixture, settings = undefined} = callbackParams;
+  if (
+    settings !== undefined
+    && typeof settings !== 'object'
+    && (fixSettings[settings as SettingsKey]) === undefined
+  ) {
+    throw new Error(`There are no settings ${settings} defined!`);
+  }
+  let runSettings: FixSettings | undefined = (fixSettings[settings as SettingsKey]) || (settings as FixSettings);
+  // metadata.json is plain JSON, so f035Filters may contain string
+  // patterns which fix.js cannot use as-is; convert them to RegExp
+  if (runSettings && runSettings.generateMissingSIDs) {
+    runSettings = {
+      ...runSettings,
+      generateMissingSIDs: {
+        ...runSettings.generateMissingSIDs,
+        f035Filters: (runSettings.generateMissingSIDs.f035Filters || []).map(
+          (filter): RegExp => (typeof filter === 'string' ? new RegExp(filter) : filter)
+        ),
+        fSIDFilters: runSettings.generateMissingSIDs.fSIDFilters
+      }
+    };
+  }
+
+  const record = new MarcRecord(getFixture('record.json') as MarcRecordObject, {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);
+
+}