@natlibfi/marc-record-validators-melinda 11.6.7 → 12.0.0-alpha.12

package/src/removeDuplicateDataFields.js

@@ -1,7 +1,7 @@
 import createDebugLogger from 'debug';
-import {fieldsToString, fieldToString, nvdebug} from './utils';
-import {fieldHasValidSubfield6, fieldsGetOccurrenceNumbers, fieldsToNormalizedString, fieldToNormalizedString, get6s} from './subfield6Utils';
-import {add8s, fieldHasLinkingNumber, fieldHasValidSubfield8, fieldsGetAllSubfield8LinkingNumbers, getSubfield8LinkingNumber, recordGetAllSubfield8LinkingNumbers, recordGetFieldsWithSubfield8LinkingNumber} from './subfield8Utils';
+import {fieldsToString, fieldToString, nvdebug} from './utils.js';
+import {fieldHasValidSubfield6, fieldsGetOccurrenceNumbers, fieldsToNormalizedString, fieldToNormalizedString, get6s} from './subfield6Utils.js';
+import {add8s, fieldHasLinkingNumber, fieldHasValidSubfield8, fieldsGetAllSubfield8LinkingNumbers, getSubfield8LinkingNumber, recordGetAllSubfield8LinkingNumbers, recordGetFieldsWithSubfield8LinkingNumber} from './subfield8Utils.js';
 
 const LINK_ROOT = 4;
 const LINKED_AND_PROCESSED = 2;
@@ -56,14 +56,13 @@ function numberOfLinkageSubfields(field) {
 */
 
 function removeLinkNotes(record) {
-  record.fields.forEach(f => delete f.linkNote); // eslint-disable-line array-callback-return
+  record.fields.forEach(f => delete f.linkNote);
 }
 
 
 function newGetAllLinkedFields(field, record, useSixes = true, useEights = true) {
   removeLinkNotes(record); // should be clear, but let's play safe
 
-  /* eslint-disable */
   field.linkNote = LINK_ROOT;
 
   let currField = field;
@@ -97,8 +96,6 @@ function newGetAllLinkedFields(field, record, useSixes = true, useEights = true)
     }
   }
 
-
-  /* eslint-enable */
 }
 
 
@@ -109,7 +106,7 @@ function recordRemoveFieldOrSubfield8(record, field, currLinkingNumber) {
     return;
   }
   const subfields = field.subfields.filter(sf => getSubfield8LinkingNumber(sf) === currLinkingNumber);
-  subfields.forEach(sf => record.removeSubfield(sf, field)); // eslint-disable-line array-callback-return
+  subfields.forEach(sf => record.removeSubfield(sf, field));
 }
 
 function newRecordRemoveFieldOrSubfield8(record, field, currLinkingNumber, fix) {
@@ -138,7 +135,6 @@ export function removeDuplicateSubfield8Chains(record, fix = true) {
   // 1 100
   // Given these stats, there's no need to check for 1XX-vs-7XX removals
 
-  /* eslint-disable */
   let seen = {};
 
   let removables = []; // for validation
@@ -178,7 +174,6 @@ export function removeDuplicateSubfield8Chains(record, fix = true) {
     return;
   });
 
-  /* eslint-enable */
   return removables;
 }
 
@@ -193,7 +188,6 @@ export function handleDuplicateSubfield8Chains(record, fix) {
   // 1 100
   // Given these stats, there's no need to check for 1XX-vs-7XX removals
 
-  /* eslint-disable */
   let seen = {};
 
   nvdebug("CHAIN-8");
@@ -222,8 +216,6 @@ export function handleDuplicateSubfield8Chains(record, fix) {
     return;
   });
 
-  /* eslint-enable */
-
 }
 
 function markIdenticalSubfield6Chains(chain, record) {
@@ -232,7 +224,7 @@ function markIdenticalSubfield6Chains(chain, record) {
   const chainAsString = fieldsToNormalizedString(chain, 0, normalizeOccurrenceNumber, normalizeTag);
 
   nvdebug(`markIdenticalSubfield6Chains: ${chainAsString}`);
-  record.fields.forEach(f => compareWithChain(f)); // eslint-disable-line array-callback-return
+  record.fields.forEach(f => compareWithChain(f));
 
 
   function compareWithChain(f) {
@@ -421,24 +413,24 @@ export function removeDuplicateDatafields(record, fix = true) {
 
   const dataFields = record.fields.filter(f => f.subfields !== undefined);
 
-  dataFields.forEach(f => fieldHandleDuplicateDatafields(f, record)); // eslint-disable-line array-callback-return
+  dataFields.forEach(f => fieldHandleDuplicateDatafields(f, record));
 
   const deletableFields = dataFields.filter(f => f.deleted);
   const modifiedFields = dataFields.filter(f => f.modified && !f.deleted);
 
   const result = deletableFields.map(f => `DEL: ${fieldToString(f)}`);
   if (modifiedFields.length) {
-    modifiedFields.forEach(f => delete f.modified); // eslint-disable-line array-callback-return
+    modifiedFields.forEach(f => delete f.modified);
     result.push(modifiedFields.map(f => `MOD: ${fieldToString(f)}`));
   }
 
   if (fix) {
-    deletableFields.forEach(f => record.removeField(f)); // eslint-disable-line array-callback-return
+    deletableFields.forEach(f => record.removeField(f));
     return result;
   }
 
-  deletableFields.forEach(f => delete f.deleted); // eslint-disable-line array-callback-return
-  deletableFields.forEach(f => delete f.modified); // eslint-disable-line array-callback-return
+  deletableFields.forEach(f => delete f.deleted);
+  deletableFields.forEach(f => delete f.modified);
 
 
   return result;

package/src/{removeDuplicateDataFields.spec.js → removeDuplicateDataFields.test.js}

@@ -1,20 +1,22 @@
-import {expect} from 'chai';
+import assert from 'node:assert';
 import {MarcRecord} from '@natlibfi/marc-record';
-import validatorFactory from './removeDuplicateDataFields';
+import validatorFactory from '../src/removeDuplicateDataFields.js';
 import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen';
 import createDebugLogger from 'debug';
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'remove-duplicate-datafields'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'remove-duplicate-datafields'],
   useMetadataFile: true,
   recurse: false,
   fixura: {
     reader: READERS.JSON
   },
-  mocha: {
-    before: () => testValidatorFactory()
+  hooks: {
+    before: async () => {
+      testValidatorFactory();
+    }
   }
 });
 const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/removeDuplicateDataFields:test');
@@ -22,12 +24,9 @@ const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/remove
 async function testValidatorFactory() {
   const validator = await validatorFactory();
 
-  expect(validator)
-    .to.be.an('object')
-    .that.has.any.keys('description', 'validate');
-
-  expect(validator.description).to.be.a('string');
-  expect(validator.validate).to.be.a('function');
+  assert.equal(typeof validator, 'object');
+  assert.equal(typeof validator.description, 'string');
+  assert.equal(typeof validator.validate, 'function');
 }
 
 async function callback({getFixture, enabled = true, fix = false}) {
@@ -43,10 +42,10 @@ async function callback({getFixture, enabled = true, fix = false}) {
 
   if (!fix) {
     const result = await validator.validate(record);
-    expect(result).to.eql(expectedResult);
+    assert.deepEqual(result, expectedResult);
     return;
   }
 
   await validator.fix(record);
-  expect(record).to.eql(expectedResult);
+  assert.deepEqual(record, expectedResult);
 }

package/src/removeInferiorDataFields.js

@@ -1,11 +1,11 @@
 import createDebugLogger from 'debug';
-import {fieldToChain, sameField} from './removeDuplicateDataFields';
-import {fieldGetOccurrenceNumberPairs, fieldHasValidSubfield6, fieldSevenToOneOccurrenceNumber, fieldsToNormalizedString} from './subfield6Utils';
-import {fieldHasSubfield, fieldsToString, fieldToString, nvdebug, uniqArray} from './utils';
-import {fieldHasValidSubfield8} from './subfield8Utils';
-import {encodingLevelIsBetterThanPrepublication, fieldRefersToKoneellisestiTuotettuTietue, getEncodingLevel} from './prepublicationUtils';
-import {cloneAndNormalizeFieldForComparison} from './normalizeFieldForComparison';
-import {fixComposition, precomposeFinnishLetters} from './normalize-utf8-diacritics';
+import {fieldToChain, sameField} from './removeDuplicateDataFields.js';
+import {fieldGetOccurrenceNumberPairs, fieldHasValidSubfield6, fieldSevenToOneOccurrenceNumber, fieldsToNormalizedString} from './subfield6Utils.js';
+import {fieldHasSubfield, fieldsToString, fieldToString, nvdebug, uniqArray} from './utils.js';
+import {fieldHasValidSubfield8} from './subfield8Utils.js';
+import {encodingLevelIsBetterThanPrepublication, fieldRefersToKoneellisestiTuotettuTietue, getEncodingLevel} from './prepublicationUtils.js';
+import {cloneAndNormalizeFieldForComparison} from './normalizeFieldForComparison.js';
+import {fixComposition, precomposeFinnishLetters} from './normalize-utf8-diacritics.js';
 
 // Relocated from melinda-marc-record-merge-reducers (and renamed)
 
@@ -46,7 +46,7 @@ function deriveInferiorChains(fields, record) {
   //nvdebug(`======= GOT ${fields.length} FIELDS TO CHAINIFY`);
   const hash = {};
 
-  fields.forEach(f => fieldToChainToDeletables(f)); // eslint-disable-line array-callback-return
+  fields.forEach(f => fieldToChainToDeletables(f));
 
   return hash;
 
@@ -151,14 +151,14 @@ export function removeInferiorChains(record, fix = true) {
 
     // If the inferior (deletable) chain is 1XX-based, convert the triggering better chain from 7XX to 1XX:
     if (chainContains1XX(chain)) {
-      triggeringChain.forEach(f => sevenToOne(f, triggeringChain)); // eslint-disable-line array-callback-return
+      triggeringChain.forEach(f => sevenToOne(f, triggeringChain));
     }
     //nvdebug(`iRIS6C: ${chainAsString}`);
     const deletedString = fieldsToString(chain);
     const message = `DEL: '${deletedString}'  REASON: '${fieldsToString(triggeringChain)}'`;
     if (fix) {
       //nvdebug(`INFERIOR $6 CHAIN REMOVAL: ${message}}`, debug);
-      chain.forEach(field => record.removeField(field)); // eslint-disable-line array-callback-return
+      chain.forEach(field => record.removeField(field));
     }
     return innerRemoveInferiorChains(remainingFields, [...deletedStringsArray, message]);
   }
@@ -176,7 +176,7 @@ export function removeInferiorChains(record, fix = true) {
     const pairs = fieldGetOccurrenceNumberPairs(field, chain);
     field.tag = `1${field.tag.substring(1)}`;
     // There should always be one pair, but I'm not sanity-checking this
-    pairs.forEach(pairedField => fieldSevenToOneOccurrenceNumber(pairedField)); // eslint-disable-line array-callback-return
+    pairs.forEach(pairedField => fieldSevenToOneOccurrenceNumber(pairedField));
   }
 
 }
@@ -332,7 +332,10 @@ function deriveIndividualDeletables(record) {
     // MET-575 (merge: applies in postprocessing)
     const inferiorTerms = getPrepublicationTerms(currString);
 
-    const newDeletables = [...deletables, ...subsets, ...accentless, ...d490, ...inferiorTerms];
+    // MELKEHITYS-3277-ish: non-AI is better than AI (a rare case where longer version is inferior):
+    const aiBased = `${currString} ‡7 (dpenmw)AI`;
+
+    const newDeletables = [...deletables, ...subsets, ...accentless, ...d490, ...inferiorTerms, aiBased];
 
     if (subsets.length) {
       return processTodoList([...stillToDo, ...moreToDo], newDeletables);

package/src/{removeInferiorDataFields.spec.js → removeInferiorDataFields.test.js}

@@ -1,33 +1,33 @@
-import {expect} from 'chai';
+import assert from 'node:assert';
 import {MarcRecord} from '@natlibfi/marc-record';
-import validatorFactory from './removeInferiorDataFields';
+import validatorFactory from './removeInferiorDataFields.js';
 import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen';
 import createDebugLogger from 'debug';
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'remove-inferior-datafields'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'remove-inferior-datafields'],
   useMetadataFile: true,
   recurse: false,
   fixura: {
     reader: READERS.JSON
   },
-  mocha: {
-    before: () => testValidatorFactory()
+  hooks: {
+    before: async () => {
+      testValidatorFactory();
+    }
   }
 });
+
 const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/removeInferiorDataFields:test');
 
 async function testValidatorFactory() {
   const validator = await validatorFactory();
 
-  expect(validator)
-    .to.be.an('object')
-    .that.has.any.keys('description', 'validate');
-
-  expect(validator.description).to.be.a('string');
-  expect(validator.validate).to.be.a('function');
+  assert.equal(typeof validator, 'object');
+  assert.equal(typeof validator.description, 'string');
+  assert.equal(typeof validator.validate).to.be.a('function');
 }
 
 async function callback({getFixture, enabled = true, fix = false}) {
@@ -43,10 +43,10 @@ async function callback({getFixture, enabled = true, fix = false}) {
 
   if (!fix) {
     const result = await validator.validate(record);
-    expect(result).to.eql(expectedResult);
+    assert.deepEqual(result, expectedResult);
     return;
   }
 
   await validator.fix(record);
-  expect(record).to.eql(expectedResult);
+  assert.deepEqual(record, expectedResult);
 }

package/src/resolvable-ext-references-melinda.js

@@ -1,5 +1,5 @@
 import {parseString} from 'xml2js';
-import fetch from 'node-fetch';
+//import fetch from 'node-fetch';
 
 export default function ({endpoint, prefixPattern, fields}) {
   if (typeof endpoint === 'string' && prefixPattern instanceof RegExp && typeof fields === 'object') {

package/src/{resolvable-ext-references-melinda.spec.js → resolvable-ext-references-melinda.test.js}

@@ -1,12 +1,14 @@
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
+import assert from 'node:assert';
+//import chai from 'chai';
+//import chaiAsPromised from 'chai-as-promised';
 import {MarcRecord} from '@natlibfi/marc-record';
 import fetchMock from 'fetch-mock';
-import * as testContext from '../src/resolvable-ext-references-melinda';
-import {fixture5000, fixture9550, fixture1000} from '../test-fixtures/resolvable-ext-references-melinda';
+import * as testContext from '../src/resolvable-ext-references-melinda.js';
+import {fixture5000, fixture9550, fixture1000} from '../test-fixtures/resolvable-ext-references-melinda.js';
+import {afterEach, beforeEach, describe, it} from 'node:test';
 
-const {expect} = chai;
-chai.use(chaiAsPromised);
+//const {expect} = chai;
+//chai.use(chaiAsPromised);
 
 const endpoint = 'http://melinda.kansalliskirjasto.fi:210/fin01';
 const queryParam = '?operation=searchRetrieve&maximumRecords=2&version=1&query=rec.id=';
@@ -16,35 +18,48 @@ const fields = {
   833: ['w', 'p']
 };
 
+
 describe('resolvable-ext-references-melinda', () => {
   afterEach(() => {
-    testContext.default.__ResetDependency__('fetch');
+    fetchMock.unmockGlobal();
+    // testContext.default.__ResetDependency__('fetch');
+  });
+
+  beforeEach(() => {
+    fetchMock.mockGlobal(); // replace fetch with fetch-mock's implementation
+    fetchMock.get(`${endpoint}${queryParam}5000`, { status: 200, headers: {}, body: fixture5000 })
+      .get(`${endpoint}${queryParam}9550`, { status: 200, headers: {}, body: fixture9550 })
+      .get(`${endpoint}${queryParam}1000`, { status: 200, headers: {}, body: fixture1000 });
+
   });
 
   it('Creates a validator', async () => {
     const validator = await testContext.default({endpoint, prefixPattern, fields});
 
-    expect(validator)
-      .to.be.an('object')
-      .that.has.any.keys('description', 'validate');
-
-    expect(validator.description).to.be.a('string');
-    expect(validator.validate).to.be.a('function');
+    assert.equal(typeof validator, 'object');
+    assert.equal(typeof validator.description, 'string');
+    assert.equal(typeof validator.validate, 'function');
   });
 
   it('Throws an error when prefixPattern not provided', async () => {
     const validator = await testContext.default({endpoint, prefixPattern, fields});
     // Cannot read property 'fields' of undefined or Cannot read properties of undefined (reading 'fields')'
-    await expect(validator.validate()).to.be.rejectedWith(Error, /^Cannot read propert/u);
+    try {
+      await validator.validate();
+      throw new Error("Test expected an error");
+    }
+    catch (err) {
+      assert.equal(err instanceof Error, true);
+      assert.match(err.message, /^Cannot read propert/u) ;
+    }
+    //await assert(validator.validate()).to.be.rejectedWith(Error, /^Cannot read propert/u);
   });
 
   describe('#validate', () => {
+
+
     it('Finds prefixPattern on record and removes it', async () => {
-      const mock = fetchMock.sandbox();
-      mock.get(`${endpoint}${queryParam}5000`, fixture5000);
-      mock.get(`${endpoint}${queryParam}9550`, fixture9550);
 
-      testContext.default.__Rewire__('fetch', mock);
       const validator = await testContext.default({endpoint, prefixPattern, fields});
 
       const record = new MarcRecord({
@@ -88,15 +103,15 @@ describe('resolvable-ext-references-melinda', () => {
       });
       const result = await validator.validate(record);
 
-      expect(result).to.eql({valid: true, messages: []});
+      assert.deepEqual(result, {valid: true, messages: []});
     });
 
     it('Finds no matching prefixPattern on record', async () => {
-      const mock = fetchMock.sandbox();
+      //const mock = fetchMock.sandbox();
 
-      mock.get(`${endpoint}5000`, fixture5000);
+      //mock.get(`${endpoint}5000`, fixture5000);
 
-      testContext.default.__Rewire__('fetch', mock);
+      //testContext.default.__Rewire__('fetch', mock);
       const validator = await testContext.default({endpoint, prefixPattern, fields});
 
       const record = new MarcRecord({
@@ -140,14 +155,14 @@ describe('resolvable-ext-references-melinda', () => {
       });
       const result = await validator.validate(record);
 
-      expect(result).to.eql({valid: true, messages: []});
+      assert.deepEqual(result, {valid: true, messages: []});
     });
 
     it('Finds prefixPattern on record but values not resolvable', async () => {
-      const mock = fetchMock.sandbox();
-      mock.get(`${endpoint}${queryParam}1000`, fixture1000);
+      //const mock = fetchMock.sandbox();
+      //mock.get(`${endpoint}${queryParam}1000`, fixture1000);
 
-      testContext.default.__Rewire__('fetch', mock);
+      //testContext.default.__Rewire__('fetch', mock);
       const validator = await testContext.default({endpoint, prefixPattern, fields});
 
       const record = new MarcRecord({
@@ -178,7 +193,7 @@ describe('resolvable-ext-references-melinda', () => {
       });
       const result = await validator.validate(record);
 
-      expect(result).to.eql({valid: false, messages: ['Field 773$w with value 1000 is not resolvable']});
+      assert.deepEqual(result, {valid: false, messages: ['Field 773$w with value 1000 is not resolvable']});
     });
   });
 });

package/src/resolveOrphanedSubfield6s.js

@@ -1,6 +1,6 @@
 import createDebugLogger from 'debug';
-import {fieldHasSubfield, fieldToString, nvdebug, subfieldToString} from './utils';
-import {fieldHasWantedTagAndOccurrenceNumber, isValidSubfield6, subfield6GetOccurrenceNumber, subfield6ResetOccurrenceNumber} from './subfield6Utils';
+import {fieldHasSubfield, fieldToString, nvdebug, subfieldToString} from './utils.js';
+import {fieldHasWantedTagAndOccurrenceNumber, isValidSubfield6, subfield6GetOccurrenceNumber, subfield6ResetOccurrenceNumber} from './subfield6Utils.js';
 
 // Relocated from melinda-marc-record-merge-reducers (and renamed)
 
@@ -41,16 +41,16 @@ export default function () {
   }
 }
 
-export function recordFixSubfield6OccurrenceNumbers(record) {
+function recordFixSubfield6OccurrenceNumbers(record) {
   const fieldsContainingSubfield6 = record.fields.filter(field => fieldHasSubfield(field, '6'));
   const orphanedFields = getOrphanedFields(fieldsContainingSubfield6);
 
-  orphanedFields.forEach(field => fieldFixOrphanedSubfields(field)); // eslint-disable-line array-callback-return
+  orphanedFields.forEach(field => fieldFixOrphanedSubfields(field));
 
   function fieldFixOrphanedSubfields(field) {
     // Field 880: orphaned $6 subfields: occurrence number is changed to '00':
     if (field.tag === '880') {
-      field.subfields.forEach(sf => field880FixOrphanedSubfield(sf)); // eslint-disable-line array-callback-return
+      field.subfields.forEach(sf => field880FixOrphanedSubfield(sf));
       return;
     }
     // Non-880 fields get their orphaned $6s removed:
@@ -78,7 +78,7 @@ function findPairForSubfield6OccurrenceNumber(subfield6, myTag, candPairFields)
     return undefined;
   }
   nvdebug(`LOOKING FOR PAIR: ${myTag} ${subfieldToString(subfield6)}`);
-  candPairFields.forEach(field => fieldToString(field)); // eslint-disable-line array-callback-return
+  candPairFields.forEach(field => fieldToString(field));
 
   // Only valid $6 value that fails to map to another field is iffy...
   const referredTag = subfield6.value.substring(0, 3);

package/src/{resolveOrphanedSubfield6s.spec.js → resolveOrphanedSubfield6s.test.js}

@@ -1,33 +1,33 @@
-import {expect} from 'chai';
+import assert from 'node:assert';
 import {MarcRecord} from '@natlibfi/marc-record';
-import validatorFactory from './resolveOrphanedSubfield6s';
+import validatorFactory from './resolveOrphanedSubfield6s.js';
 import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen';
 import createDebugLogger from 'debug';
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'remove-orphanded-sf6s'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'remove-orphanded-sf6s'],
   useMetadataFile: true,
   recurse: false,
   fixura: {
     reader: READERS.JSON
   },
-  mocha: {
-    before: () => testValidatorFactory()
+  hooks: {
+    before: async () => {
+      testValidatorFactory();
+    }
   }
 });
+
 const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/resolveOrphanedSubfield6s:test');
 
 async function testValidatorFactory() {
   const validator = await validatorFactory();
 
-  expect(validator)
-    .to.be.an('object')
-    .that.has.any.keys('description', 'validate');
-
-  expect(validator.description).to.be.a('string');
-  expect(validator.validate).to.be.a('function');
+  assert.equal(typeof validator, 'object');
+  assert.equal(typeof validator.description, 'string');
+  assert.equal(typeof validator.validate, 'function');
 }
 
 async function callback({getFixture, enabled = true, fix = false}) {
@@ -43,10 +43,10 @@ async function callback({getFixture, enabled = true, fix = false}) {
 
   if (!fix) {
     const result = await validator.validate(record);
-    expect(result).to.eql(expectedResult);
+    assert.deepEqual(result, expectedResult);
     return;
   }
 
   await validator.fix(record);
-  expect(record).to.eql(expectedResult);
+  assert.deepEqual(record, expectedResult);
 }

package/src/sanitize-vocabulary-source-codes.js

@@ -1,5 +1,5 @@
 //import createDebugLogger from 'debug';
-import {fieldToString} from './utils';
+import {fieldToString} from './utils.js';
 import clone from 'clone';
 
 //const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/sanitize-vocabulary-source-codes);
@@ -15,7 +15,7 @@ export default function () {
   function fix(record) {
     const res = {message: [], fix: [], valid: true};
     const relevantFields = getRelevantFields(record);
-    relevantFields.forEach(f => fieldSanitizeVocabularySourceCode(f)); // eslint-disable-line array-callback-return
+    relevantFields.forEach(f => fieldSanitizeVocabularySourceCode(f));
     return res;
   }
 
@@ -23,7 +23,7 @@ export default function () {
     const res = {message: []};
     const relevantFields = getRelevantFields(record);
 
-    relevantFields.forEach(field => validateField(field, res)); // eslint-disable-line array-callback-return
+    relevantFields.forEach(field => validateField(field, res));
 
     res.valid = !(res.message.length >= 1);
     return res;
@@ -52,7 +52,7 @@ export default function () {
 
 
   function fieldSanitizeVocabularySourceCode(field) {
-    field.subfields.forEach(sf => subfieldSanitizeVocabularySourceCode(sf)); // eslint-disable-line array-callback-return
+    field.subfields.forEach(sf => subfieldSanitizeVocabularySourceCode(sf));
     return field;
   }
 

package/src/{sanitize-vocabulary-source-codes.spec.js → sanitize-vocabulary-source-codes.test.js}

@@ -1,20 +1,22 @@
-import {expect} from 'chai';
+import assert from 'node:assert';
 import {MarcRecord} from '@natlibfi/marc-record';
-import validatorFactory from './sanitize-vocabulary-source-codes';
+import validatorFactory from './sanitize-vocabulary-source-codes.js';
 import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen';
 import createDebugLogger from 'debug';
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'sanitize-vocabulary-source-codes'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'sanitize-vocabulary-source-codes'],
   useMetadataFile: true,
   recurse: false,
   fixura: {
     reader: READERS.JSON
   },
-  mocha: {
-    before: () => testValidatorFactory()
+  hooks: {
+    before: async () => {
+      testValidatorFactory();
+    }
   }
 });
 const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/sanitize-vocabulary-source-codes:test');
@@ -22,12 +24,9 @@ const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/saniti
 async function testValidatorFactory() {
   const validator = await validatorFactory();
 
-  expect(validator)
-    .to.be.an('object')
-    .that.has.any.keys('description', 'validate');
-
-  expect(validator.description).to.be.a('string');
-  expect(validator.validate).to.be.a('function');
+  assert.equal(typeof validator, 'object');
+  assert.equal(typeof validator.description, 'string');
+  assert.equal(typeof validator.validate, 'function');
 }
 
 async function callback({getFixture, enabled = true, fix = false}) {
@@ -37,16 +36,19 @@ async function callback({getFixture, enabled = true, fix = false}) {
   }
 
   const validator = await validatorFactory();
-  const record = new MarcRecord(getFixture('record.json'));
+
+  const recordFixture = getFixture('record.json');
+  const record = recordFixture._validationOptions ? new MarcRecord(recordFixture, recordFixture._validationOptions) : new MarcRecord(recordFixture);
+
   const expectedResult = getFixture('expectedResult.json');
   // console.log(expectedResult); // eslint-disable-line
 
   if (!fix) {
     const result = await validator.validate(record);
-    expect(result).to.eql(expectedResult);
+    assert.deepEqual(result, expectedResult);
     return;
   }
 
   await validator.fix(record);
-  expect(record).to.eql(expectedResult);
+  assert.deepEqual(record, expectedResult);
 }