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

package/src/{sort-tags.spec.js → sort-tags.test.js}

@@ -1,17 +1,15 @@
-import {expect} from 'chai';
+import assert from 'node:assert';
 import {MarcRecord} from '@natlibfi/marc-record';
-import validatorFactory from '../src/sort-tags';
+import validatorFactory from '../src/sort-tags.js';
+import {describe, it} from 'node:test';
 
 describe('sort-tags', () => {
   it('Creates a validator', async () => {
     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');
   });
 
   describe('#validate', () => {
@@ -53,7 +51,7 @@ describe('sort-tags', () => {
       });
       const result = await validator.validate(record);
 
-      expect(result).to.eql({valid: true, messages: []});
+      assert.deepEqual(result, {valid: true, messages: []});
     });
     it('Finds the record invalid', async () => {
       const validator = await validatorFactory();
@@ -92,7 +90,7 @@ describe('sort-tags', () => {
         ]
       });
       const result = await validator.validate(record);
-      expect(result).to.eql({valid: false, messages: ['Fields are in incorrect order']});
+      assert.deepEqual(result, {valid: false, messages: ['Fields are in incorrect order']});
     });
   });
 
@@ -182,7 +180,7 @@ describe('sort-tags', () => {
         ]
       });
       await validator.fix(record);
-      expect(record.fields).to.eql([
+      assert.deepEqual(record.fields, [
         {
           tag: '001',
           value: '100'

package/src/sortFields.js

@@ -2,10 +2,10 @@
 
 import clone from 'clone';
 //import createDebugLogger from 'debug';
-import {fieldHasSubfield, fieldToString} from './utils';
-import {sortByTag, sortAlphabetically, fieldOrderComparator as globalFieldOrderComparator} from '@natlibfi/marc-record/dist/marcFieldSort';
-import {isValidSubfield8} from './subfield8Utils';
-import {fieldGetUnambiguousOccurrenceNumber, fieldGetUnambiguousTag} from './subfield6Utils';
+import {fieldHasSubfield, fieldToString} from './utils.js';
+import {sortByTag, sortAlphabetically, fieldOrderComparator as globalFieldOrderComparator} from '@natlibfi/marc-record/dist/marcFieldSort.js';
+import {isValidSubfield8} from './subfield8Utils.js';
+import {fieldGetUnambiguousOccurrenceNumber, fieldGetUnambiguousTag} from './subfield6Utils.js';
 
 //const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:sortFields');
 //const debugData = debug.extend('data');

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

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

@@ -4,9 +4,9 @@
 
 import clone from 'clone';
 //import createDebugLogger from 'debug';
-import {fieldToString} from './utils';
-import {fieldFixPunctuation} from './punctuation2';
-import {scoreRelatorTerm} from './sortFields';
+import {fieldToString} from './utils.js';
+import {fieldFixPunctuation} from './punctuation2.js';
+import {scoreRelatorTerm} from './sortFields.js';
 //const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:sortRelatorTerms');
 //const debugData = debug.extend('data');
 

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

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

@@ -2,7 +2,7 @@
 
 import clone from 'clone';
 import createDebugLogger from 'debug';
-import {fieldToString, nvdebug} from './utils';
+import {fieldToString, nvdebug} from './utils.js';
 
 const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:sortSubfields');
 //const debugData = debug.extend('data');
@@ -67,9 +67,9 @@ export default function (defaultTagPattern) {
 
 // X00, X10, X11 and X130 could also for their own sets...
 // (ouch! sometimes $c comes after $d...): LoC: 100 0# ‡a Black Foot, ‡c Chief, ‡d d. 1877 ‡c (Spirit)
-const sortOrderForX00 = ['i', 'a', 'b', 'q', 'c', 'd', 'e', 't', 'u', 'l', 'f', 'x', 'y', 'z', '0', '5', '9']; // skip $g. Can't remember why, though...
-const sortOrderForX10 = ['i', 'a', 'b', 't', 'n', 'c', 'e', 'v', 'w', 'x', 'y', 'z', '0', '5', '9']; // somewhat iffy
-const sortOrderForX11 = ['a', 'n', 'd', 'c', 'e', 'g', 'j', '0', '5', '9'];
+const sortOrderForX00 = ['i', 'a', 'b', 'q', 'c', 'd', 'e', 't', 'u', 'l', 'f', 'x', 'y', 'z', '0', '1', '5', '9']; // skip $g. Can't remember why, though...
+const sortOrderForX10 = ['i', 'a', 'b', 't', 'n', 'c', 'e', 'v', 'w', 'x', 'y', 'z', '0', '1', '5', '9']; // somewhat iffy
+const sortOrderForX11 = ['a', 'n', 'd', 'c', 'e', 'g', 'j', '0', '1', '5', '9'];
 const sortOrderFor7XX = ['8', '7', 'i', 'a', 's', 't', 'b', 'c', 'd', 'm', 'h', 'k', 'o', 'x', 'z', 'g', 'q', 'w'];
 const sortOrderFor246 = ['i', 'a', 'b', 'n', 'p', 'f', '5', '9']; // Used by field 946 as well
 
@@ -89,7 +89,7 @@ const subfieldSortOrder = [
   {'tag': '245', 'sortOrder': ['a', 'b', 'n', 'p', 'k', 'f', 'c']},
   {'tag': '246', 'sortOrder': sortOrderFor246},
   {'tag': '382', 'sortOrder': ['a']},
-  {'tag': '385', 'sortOrder': ['8', 'm', 'n', 'a', '2', '0']},
+  {'tag': '385', 'sortOrder': ['8', 'm', 'n', 'a', '2', '0', '1']},
   {'tag': '386', 'sortOrder': ['8', 'm', 'n', 'a']},
   {'tag': '490', 'sortOrder': ['a', 'x', 'y', 'v', 'l']},
   {'tag': '505', 'sortOrder': ['a']},
@@ -218,7 +218,9 @@ export function sortAdjacentSubfields(field, externalSortOrder = []) {
 
 
   const finnishWay = twoBeforeZero(field);
-  const controlSubfieldOrder = finnishWay ? ['8', '7', '3', 'a', '4', '2', '0', '1', '5', '9'] : ['8', '7', '3', 'a', '4', '0', '2', '1', '5', '9'];
+
+  // Note: 760-789: '7' comes way earlier (after '6' and '8')
+  const controlSubfieldOrder = finnishWay ? ['8', '3', 'a', '4', '2', '0', '1', '7', '5', '9'] : ['8', '7', '3', 'a', '4', '0', '1', '2', '7', '5', '9'];
   swapSubfields(field, controlSubfieldOrder);
 
   const sortOrderForField = externalSortOrder.length > 0 ? externalSortOrder : getSubfieldSortOrder(field);

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

@@ -1,33 +1,33 @@
-import {expect} from 'chai';
+import assert from 'node:assert';
 import {MarcRecord} from '@natlibfi/marc-record';
-import validatorFactory from './sortSubfields';
+import validatorFactory from './sortSubfields.js';
 import {READERS} from '@natlibfi/fixura';
 import generateTests from '@natlibfi/fixugen';
 import createDebugLogger from 'debug';
 
 generateTests({
   callback,
-  path: [__dirname, '..', 'test-fixtures', 'sort-subfields'],
+  path: [import.meta.dirname, '..', 'test-fixtures', 'sort-subfields'],
   useMetadataFile: true,
   recurse: false,
   fixura: {
     reader: READERS.JSON
   },
-  mocha: {
-    before: () => testValidatorFactory()
+  hooks: {
+    before: async () => {
+      testValidatorFactory();
+    }
   }
 });
+
 const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/sortSubfields: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, tagPattern = false}) {
@@ -43,10 +43,10 @@ async function callback({getFixture, enabled = true, fix = false, tagPattern = f
 
   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/stripPunctuation.js

@@ -5,9 +5,9 @@
 *
 */
 
-import {fieldGetFixedString, fieldNeedsModification, fieldStripPunctuation} from './punctuation2';
+import {fieldGetFixedString, fieldNeedsModification, fieldStripPunctuation} from './punctuation2.js';
 // import createDebugLogger from 'debug';
-import {fieldToString, nvdebug} from './utils';
+import {fieldToString, nvdebug} from './utils.js';
 
 // const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/punctuation2');
 
@@ -20,7 +20,7 @@ export default function () {
   function fix(record) {
     nvdebug('Strip punctuation to data fields: fixer');
     const res = {message: [], fix: [], valid: true};
-    record.fields.forEach(f => fieldStripPunctuation(f)); // eslint-disable-line array-callback-return
+    record.fields.forEach(f => fieldStripPunctuation(f));
     return res;
   }
 

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

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

@@ -146,7 +146,7 @@ export default function (config) {
               }
             });
 
-            excluded.forEach(sf => record.removeSubfield(sf, element)); // eslint-disable-line array-callback-return
+            excluded.forEach(sf => record.removeSubfield(sf, element));
             // If no subfields remains, the whole field will be removed as well:
             if (element.subfields && element.subfields.length === 0) {
               record.removeField(element);

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);
     });
   });
 });