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

package/src/{subfield-exclusion.spec.js → subfield-exclusion.test.js}

@@ -1,7 +1,7 @@
-import {expect} from 'chai';
-//import chaiAsPromised from 'chai-as-promised';
+import assert from 'node:assert';
 import {MarcRecord} from '@natlibfi/marc-record';
-import validatorFactory from '../src/subfield-exclusion';
+import validatorFactory from '../src/subfield-exclusion.js';
+import {describe, it} from 'node:test';
 
 //chai.use(chaiAsPromised);
 
@@ -17,12 +17,9 @@ describe('subfield-exclusion', () => {
       ];
 
       const validator = await validatorFactory(config);
-      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('Creates a validator from complex config', async () => {
@@ -40,12 +37,9 @@ describe('subfield-exclusion', () => {
       ];
 
       const validator = await validatorFactory(config);
-      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('Fails to create a validator from invalid config - subfields missing', () => {
@@ -58,7 +52,8 @@ describe('subfield-exclusion', () => {
       try {
         validatorFactory(config);
       } catch (error) {
-        expect(error).to.be.an('error').with.property('message', 'Configuration not valid - missing mandatory element: subfields');
+        assert.equal(error instanceof Error, true);
+        assert.equal(error.message, 'Configuration not valid - missing mandatory element: subfields');
       }
     });
 
@@ -73,7 +68,8 @@ describe('subfield-exclusion', () => {
       try {
         validatorFactory(config);
       } catch (error) {
-        expect(error).to.be.an('error').with.property('message', 'Configuration not valid - invalid data type for: tag');
+        assert.equal(error instanceof Error, true);
+        assert.equal(error.message, 'Configuration not valid - invalid data type for: tag');
       }
     });
 
@@ -86,7 +82,8 @@ describe('subfield-exclusion', () => {
       try {
         validatorFactory(config);
       } catch (error) {
-        expect(error).to.be.an('error').with.property('message', 'Configuration array not provided');
+        assert.equal(error instanceof Error, true);
+        assert.equal(error.message, 'Configuration array not provided');
       }
     });
 
@@ -101,7 +98,8 @@ describe('subfield-exclusion', () => {
       try {
         validatorFactory(config);
       } catch (error) {
-        expect(error).to.be.an('error').with.property('message', 'Configuration not valid - invalid data type for: code');
+        assert.equal(error instanceof Error, true);
+        assert.equal(error.message, 'Configuration not valid - invalid data type for: code');
       }
     });
 
@@ -116,7 +114,8 @@ describe('subfield-exclusion', () => {
       try {
         validatorFactory(config);
       } catch (error) {
-        expect(error).to.be.an('error').with.property('message', 'Configuration not valid - invalid data type for: value');
+        assert.equal(error instanceof Error, true);
+        assert.equal(error.message, 'Configuration not valid - invalid data type for: value');
       }
     });
 
@@ -132,7 +131,8 @@ describe('subfield-exclusion', () => {
       try {
         validatorFactory(config);
       } catch (error) {
-        expect(error).to.be.an('error').with.property('message', 'Configuration not valid - missing mandatory element: tag');
+        assert.equal(error instanceof Error, true);
+        assert.equal(error.message, 'Configuration not valid - missing mandatory element: tag');
       }
     });
 
@@ -150,7 +150,8 @@ describe('subfield-exclusion', () => {
       try {
         validatorFactory(config);
       } catch (error) {
-        expect(error).to.be.an('error').with.property('message', 'Configuration not valid - subfield: /9/,/^(?!FENNI<KEEP>).*$/ not object');
+        assert.equal(error instanceof Error, true);
+        assert.equal(error.message, 'Configuration not valid - subfield: /9/,/^(?!FENNI<KEEP>).*$/ not object');
       }
     });
 
@@ -169,7 +170,8 @@ describe('subfield-exclusion', () => {
       try {
         validatorFactory(config);
       } catch (error) {
-        expect(error).to.be.an('error').with.property('message', 'Configuration not valid - subfield: /9/ not object');
+        assert.equal(error instanceof Error, true);
+        assert.equal(error.message, 'Configuration not valid - subfield: /9/ not object');
       }
     });
 
@@ -187,7 +189,8 @@ describe('subfield-exclusion', () => {
       try {
         validatorFactory(config);
       } catch (error) {
-        expect(error).to.be.an('error').with.property('message', 'Configuration not valid - missing mandatory element: code');
+        assert.equal(error instanceof Error, true);
+        assert.equal(error.message, 'Configuration not valid - missing mandatory element: code');
       }
     });
 
@@ -206,7 +209,9 @@ describe('subfield-exclusion', () => {
       try {
         validatorFactory(config);
       } catch (error) {
-        expect(error).to.be.an('error').with.property('message', 'Configuration not valid - unidentified value: unidentified');
+        assert.equal(error instanceof Error, true);
+        assert.equal(error.message, 'Configuration not valid - unidentified value: unidentified');
+        //assert(error).to.be.an('error').with.property('message', 'Configuration not valid - unidentified value: unidentified');
       }
     });
   });
@@ -277,19 +282,20 @@ describe('subfield-exclusion', () => {
     it('Finds the record valid (spec)', async () => {
       const validator = await validatorFactory(config);
       const result = await validator.validate(recordValid);
-      expect(result).to.eql({valid: true, message: []});
+      assert.deepEqual(result, {valid: true, message: []});
     });
 
     it('Finds the record invalid (spec)', async () => {
       const validator = await validatorFactory(config);
       const result = await validator.validate(recordInvalid);
-      expect(result).to.eql({valid: false, message: ['Subfield $100$$4should be excluded']});
+      assert.deepEqual(result, {valid: false, message: ['Subfield $100$$4should be excluded']});
     });
 
     it('Repairs invalid record', async () => {
       const validator = await validatorFactory(config);
       await validator.fix(recordInvalid);
-      expect(recordInvalid.equalsTo(recordInvalidFixed)).to.eql(true);
+      //assert(recordInvalid.equalsTo(recordInvalidFixed)).to.eql(true);
+      assert(recordInvalid.equalsTo(recordInvalidFixed), true);
     });
   });
 
@@ -334,13 +340,14 @@ describe('subfield-exclusion', () => {
     it('Finds the record with 041$a zxx invalid (spec)', async () => {
       const validator = await validatorFactory(config);
       const result = await validator.validate(recordOriginal);
-      expect(result).to.eql({valid: false, message: ['Subfield $041$$ashould be excluded']});
+      assert.deepEqual(result, {valid: false, message: ['Subfield $041$$ashould be excluded']});
     });
 
     it('Repairs invalid record', async () => {
       const validator = await validatorFactory(config);
       await validator.fix(recordOriginal);
-      expect(recordOriginal.equalsTo(recordModified)).to.eql(true);
+      //assert(recordOriginal.equalsTo(recordModified)).to.eql(true);
+      assert.equal(recordOriginal.equalsTo(recordModified), true);
     });
   });
 
@@ -411,19 +418,20 @@ describe('subfield-exclusion', () => {
     it('Finds the record valid (spec)', async () => {
       const validator = await validatorFactory(config);
       const result = await validator.validate(recordValid);
-      expect(result).to.eql({valid: true, message: []});
+      assert.deepEqual(result, {valid: true, message: []});
     });
 
     it('Finds the record invalid (spec)', async () => {
       const validator = await validatorFactory(config);
       const result = await validator.validate(recordInvalid);
-      expect(result).to.eql({valid: false, message: ['Subfield $210$$2should be excluded']});
+      assert.deepEqual(result, {valid: false, message: ['Subfield $210$$2should be excluded']});
     });
 
     it('Repairs invalid record', async () => {
       const validator = await validatorFactory(config);
       await validator.fix(recordInvalid);
-      expect(recordInvalid.equalsTo(recordInvalidFixed)).to.eql(true);
+      // assert(recordInvalid.equalsTo(recordInvalidFixed)).to.eql(true);
+      assert.equal(recordInvalid.equalsTo(recordInvalidFixed), true);
     });
   });
 
@@ -496,19 +504,20 @@ describe('subfield-exclusion', () => {
     it('Finds the record valid - Ind1&Ind2', async () => {
       const validator = await validatorFactory(configInd);
       const result = await validator.validate(recordValid);
-      expect(result).to.eql({valid: true, message: []});
+      assert.deepEqual(result, {valid: true, message: []});
     });
 
     it('Finds the record invalid - Ind', async () => {
       const validator = await validatorFactory(configInd);
       const result = await validator.validate(recordIndInvalid);
-      expect(result).to.eql({valid: false, message: ['Subfield $500$$2should be excluded']});
+      assert.deepEqual(result, {valid: false, message: ['Subfield $500$$2should be excluded']});
     });
 
     it('Repairs invalid record', async () => {
       const validator = await validatorFactory(configInd);
       await validator.fix(recordIndInvalid);
-      expect(recordIndInvalid.equalsTo(recordIndInvalidFixed)).to.eql(true);
+      // assert(recordIndInvalid.equalsTo(recordIndInvalidFixed)).to.eql(true);
+      assert.equal(recordIndInvalid.equalsTo(recordIndInvalidFixed), true);
     });
   });
 });

package/src/subfield6Utils.js

@@ -1,8 +1,8 @@
 import createDebugLogger from 'debug';
 // const debug = createDebugLogger('@natlibfi/marc-record-validator-melinda/subfield6Utils');
 
-import {add8s, fieldsGetAllSubfield8LinkingNumbers, getSubfield8LinkingNumber, isValidSubfield8} from './subfield8Utils';
-import {fieldHasSubfield, fieldToString, fieldsToString, nvdebug, subfieldToString} from './utils';
+import {add8s, fieldsGetAllSubfield8LinkingNumbers, getSubfield8LinkingNumber, isValidSubfield8} from './subfield8Utils.js';
+import {fieldHasSubfield, fieldToString, fieldsToString, nvdebug, subfieldToString} from './utils.js';
 
 const debug = createDebugLogger('@natlibfi/melinda-marc-record-merge-reducers:subfield6Utils');
 //const debugData = debug.extend('data');
@@ -99,7 +99,7 @@ export function fieldHasOccurrenceNumber(field, occurrenceNumber) {
 }
 
 export function fieldResetOccurrenceNumber(field, newOccurrenceNumber, oldOccurrenceNumber = undefined) {
-  field.subfields.forEach(subfield => innerReset(subfield)); // eslint-disable-line array-callback-return
+  field.subfields.forEach(subfield => innerReset(subfield));
 
   function innerReset(subfield) {
     // (Optional) Check that this is really the occurrence number we wan't to reseot
@@ -210,7 +210,7 @@ export function fieldSevenToOneOccurrenceNumber(field) {
   if (field.tag !== '880') {
     return;
   }
-  field.subfields.forEach(sf => subfieldSevenToOneOccurrenceNumber(sf)); // eslint-disable-line array-callback-return
+  field.subfields.forEach(sf => subfieldSevenToOneOccurrenceNumber(sf));
 }
 
 
@@ -223,12 +223,11 @@ export function fieldGetOccurrenceNumberPairs(field, candFields) {
     return pairs;
   }
   nvdebug(`${pairs.length} PAIR(S) FOUND FOR '${fieldToString(field)}'`);
-  pairs.forEach(pairedField => nvdebug(`  '${fieldToString(pairedField)}'`)); // eslint-disable-line array-callback-return
+  pairs.forEach(pairedField => nvdebug(`  '${fieldToString(pairedField)}'`));
   return pairs;
 }
 
 export function fieldGetOccurrenceNumbers(field) {
-  /* eslint-disable */
   let occurrenceNumbers = [];
   field.subfields?.forEach(sf => subfieldExtractOccurrenceNumber(sf));
 
@@ -242,12 +241,10 @@ export function fieldGetOccurrenceNumbers(field) {
     }
     occurrenceNumbers.push(occurrenceNumber);
   }
-  /* eslint-enable */
   return occurrenceNumbers;
 }
 
 export function fieldsGetOccurrenceNumbers(fields) {
-  /* eslint-disable */
   let occurrenceNumbers = [];
 
   fields.forEach(f => fieldProcessOccurrenceNumbers(f));
@@ -261,7 +258,6 @@ export function fieldsGetOccurrenceNumbers(fields) {
 
     });
   }
-  /* eslint-enable */
   return occurrenceNumbers;
 }
 
@@ -482,7 +478,7 @@ export function get6s(field, candidateFields) { // NB! Convert field to fields!!
 
   const relevantFields = candidateFields.filter(f => occurrenceNumbers.some(o => fieldHasOccurrenceNumber(f, o)));
   nvdebug(`${fieldToString(field)}: $6-RELFIELDS FOUND: ${relevantFields.length}...`);
-  relevantFields.forEach(f => nvdebug(fieldToString(f))); // eslint-disable-line array-callback-return
+  relevantFields.forEach(f => nvdebug(fieldToString(f)));
   return relevantFields;
 }
 

package/src/subfield8Utils.js

@@ -1,7 +1,7 @@
 // import createDebugLogger from 'debug';
 // const debug = createDebugLogger('@natlibfi/marc-record-validator-melinda/subfield8Utils');
 
-import {fieldToString, nvdebug} from './utils';
+import {fieldToString, nvdebug} from './utils.js';
 
 const sf8Regexp = /^([1-9][0-9]*)(?:\.[0-9]+)?(?:\\[acprux])?$/u;
 
@@ -77,9 +77,9 @@ export function add8s(fields, record) {
   }
 
   nvdebug(`Linking number(s): ${linkingNumbers.join(', ')}`);
-  linkingNumbers.forEach(number => collectLinkingNumberFields(number)); // eslint-disable-line array-callback-return
+  linkingNumbers.forEach(number => collectLinkingNumberFields(number));
 
-  fields.forEach(f => nvdebug(`AFTER ADDING 8s: '${fieldToString(f)}'`)); // eslint-disable-line array-callback-return
+  fields.forEach(f => nvdebug(`AFTER ADDING 8s: '${fieldToString(f)}'`));
 
   return fields;
 
@@ -88,7 +88,7 @@ export function add8s(fields, record) {
     fields = fields.filter(f => !fieldHasLinkingNumber(f, linkingNumber));
     // Add them and their "sisters" back:
     const addableFields = record.fields.filter(f => fieldHasLinkingNumber(f, linkingNumber));
-    addableFields.forEach(f => nvdebug(`(RE-?)ADD ${fieldToString(f)}`));  // eslint-disable-line array-callback-return
+    addableFields.forEach(f => nvdebug(`(RE-?)ADD ${fieldToString(f)}`));
     fields = fields.concat(addableFields);
 
   }

package/src/subfieldValueNormalizations.js

@@ -1,8 +1,8 @@
 //import createDebugLogger from 'debug';
 import clone from 'clone';
-import {fieldHasSubfield, fieldToString, getCatalogingLanguage} from './utils';
-import {fieldFixPunctuation} from './punctuation2';
-import {fieldGetUnambiguousTag} from './subfield6Utils';
+import {fieldHasSubfield, fieldToString, getCatalogingLanguage} from './utils.js';
+import {fieldFixPunctuation} from './punctuation2.js';
+import {fieldGetUnambiguousTag} from './subfield6Utils.js';
 
 // NB! You should probably run punctuation fixes after this validator!
 

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

@@ -1,33 +1,33 @@
-import {expect} from 'chai';
+import assert from 'node:assert';
 import {MarcRecord} from '@natlibfi/marc-record';
-import validatorFactory from './subfieldValueNormalizations';
+import validatorFactory from './subfieldValueNormalizations.js';
 import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen';
 import createDebugLogger from 'debug';
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'normalize-subfield-value'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'normalize-subfield-value'],
   useMetadataFile: true,
   recurse: false,
   fixura: {
     reader: READERS.JSON
   },
-  mocha: {
-    before: () => testValidatorFactory()
+  hooks: {
+    before: async () => {
+      testValidatorFactory();
+    }
   }
 });
+
 const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/subfieldValueNormalizations: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, 'string');
+  assert.equal(typeof validator, 'function');
 }
 
 async function callback({getFixture, enabled = true, fix = false}) {
@@ -37,16 +37,20 @@ 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 record = new MarcRecord(recordFixture, {"subfields": false}); // works
   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);
 }

package/src/sync-007-and-300.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);
@@ -14,7 +14,7 @@ export default function () {
 
   function fix(record) {
     const res = {message: [], fix: [], valid: true};
-    record.fields.forEach(f => fixField(f, record)); // eslint-disable-line array-callback-return
+    record.fields.forEach(f => fixField(f, record));
     return res;
   }
 

package/src/{sync-007-and-300.spec.js → sync-007-and-300.test.js}

@@ -1,33 +1,33 @@
-import {expect} from 'chai';
+import assert from 'node:assert';
 import {MarcRecord} from '@natlibfi/marc-record';
-import validatorFactory from './sync-007-and-300';
+import validatorFactory from './sync-007-and-300.js';
 import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen';
 import createDebugLogger from 'debug';
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'sync-007-and-300'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'sync-007-and-300'],
   useMetadataFile: true,
   recurse: false,
   fixura: {
     reader: READERS.JSON
   },
-  mocha: {
-    before: () => testValidatorFactory()
+  hooks: {
+    before: async () => {
+      testValidatorFactory();
+    }
   }
+
 });
 const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/sync-007-and-300: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/translate-terms.js

@@ -1,6 +1,6 @@
 import clone from 'clone';
 import createDebugLogger from 'debug';
-import {fieldHasSubfield, fieldToString, nvdebug} from './utils';
+import {fieldHasSubfield, fieldToString, nvdebug} from './utils.js';
 
 
 const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:translate-terms');
@@ -23,9 +23,9 @@ export default function () {
   async function fix(record) {
     const newFields = await getFields(record, defaultTags, []);
 
-    newFields.forEach(nf => nvdebug(`Add new field '${fieldToString(nf)}'`, debug)); // eslint-disable-line array-callback-return
+    newFields.forEach(nf => nvdebug(`Add new field '${fieldToString(nf)}'`, debug));
 
-    newFields.forEach(nf => record.insertField(nf)); // eslint-disable-line array-callback-return
+    newFields.forEach(nf => record.insertField(nf));
 
     const newFieldsAsStrings = newFields.map(f => fieldToString(f));
 

package/src/{translate-terms.spec.js → translate-terms.test.js}

@@ -1,33 +1,33 @@
-import {expect} from 'chai';
+import assert from 'node:assert';
 import {MarcRecord} from '@natlibfi/marc-record';
-import validatorFactory from './translate-terms';
+import validatorFactory from './translate-terms.js';
 import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen';
 import createDebugLogger from 'debug';
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'translate-terms'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'translate-terms'],
   useMetadataFile: true,
   recurse: false,
   fixura: {
     reader: READERS.JSON
   },
-  mocha: {
-    before: () => testValidatorFactory()
+  hooks: {
+    before: async () => {
+      testValidatorFactory();
+    }
   }
 });
+
 const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/translate-terms: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/{typeOfDate-008.spec.js → typeOfDate-008.test.js}

@@ -1,20 +1,22 @@
-import {expect} from 'chai';
+import assert from 'node:assert';
 import {MarcRecord} from '@natlibfi/marc-record';
-import validatorFactory from './typeOfDate-008';
+import validatorFactory from './typeOfDate-008.js';
 import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen';
 import createDebugLogger from 'debug';
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'typeOfDate-008'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'typeOfDate-008'],
   useMetadataFile: true,
   recurse: false,
   fixura: {
     reader: READERS.JSON
   },
-  mocha: {
-    before: () => testValidatorFactory()
+  hooks: {
+    before: async () => {
+      testValidatorFactory();
+    }
   }
 });
 const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/typeOfDate-008:test');  // eslint-disable-line
@@ -22,12 +24,9 @@ const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/typeOf
 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, fix = false}) {
@@ -38,10 +37,10 @@ async function callback({getFixture, 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);
 }