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

package/src/{ending-punctuation.spec.js → ending-punctuation.test.js}

@@ -1,10 +1,9 @@
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
+import assert from 'node:assert';
 import {MarcRecord} from '@natlibfi/marc-record';
-import validatorFactory from '../src/ending-punctuation';
+import validatorFactory from '../src/ending-punctuation.js';
+import {describe, it} from 'node:test';
+
 
-const {expect} = chai;
-chai.use(chaiAsPromised);
 
 // Factory validation
 describe('ending-punctuation', () => {
@@ -18,10 +17,18 @@ describe('ending-punctuation', () => {
           ind1: ' ',
           ind2: ' ',
           subfields: [
-            {code: 'a', value: 'Elämäni ja tutkimusretkeni / '},
+            {code: 'a', value: 'Elämäni ja tutkimusretkeni /'},
             {code: 'c', value: 'Roald Amundsen ; suomentanut Sulo Veikko Pekkola.'},
             {code: '6', value: 'FOO'}
           ]
+        }, { // Hackily putting 2nd 245 here
+          tag: '245',
+          ind1: '0',
+          ind2: '4',
+          subfields: [
+            {code: 'a', value: 'The Disaster /'},
+            {code: 'c', value: '(J.L.).'}
+          ]
         }, {
           tag: '337', // Range 336-338
           ind1: ' ',
@@ -35,7 +42,18 @@ describe('ending-punctuation', () => {
           tag: '500', // Range 500-509
           ind1: ' ',
           ind2: ' ',
-          subfields: [{code: 'a', value: 'FOO (Bar)'}]
+          subfields: [{code: 'a', value: 'FOO (Bar).'}]
+        }, {
+          tag: '500', // Range 500-509
+          ind1: ' ',
+          ind2: ' ',
+          subfields: [{code: 'a', value: '"Lorum ipsum."'}]
+        },
+        {
+          tag: '500', // Range 500-509
+          ind1: ' ',
+          ind2: ' ',
+          subfields: [{code: 'a', value: 'Foo "Bar".'}]
         }
       ]
     });
@@ -48,9 +66,17 @@ describe('ending-punctuation', () => {
           ind1: ' ',
           ind2: ' ',
           subfields: [
-            {code: 'a', value: 'Elämäni ja tutkimusretkeni / '},
+            {code: 'a', value: 'Elämäni ja tutkimusretkeni /'},
             {code: 'c', value: 'Roald Amundsen ; suomentanut Sulo Veikko Pekkola'},
-            {code: '6', value: 'FOO'}
+            {code: '6', value: 'FOO'} // NV: not changing this now, but this is wrong: $6 is *always* the first subfield. Also , the value is not valid for $6...
+          ]
+        }, { // Hackily putting 2nd 245 here
+          tag: '245',
+          ind1: '0',
+          ind2: '4',
+          subfields: [
+            {code: 'a', value: 'The Disaster /'},
+            {code: 'c', value: '(J.L.)'}
           ]
         }, {
           tag: '337',
@@ -58,14 +84,25 @@ describe('ending-punctuation', () => {
           ind2: ' ',
           subfields: [
             {code: 'a', value: 'käytettävissä ilman laitetta'},
-            {code: 'b', value: 'n.'}, // This can be abbreviation -> does not generate error
+            {code: 'b', value: 'n.'}, // This can be abbreviation -> does not generate error (NV: huh?!?)
             {code: '2', value: 'rdamedia'}
           ]
         }, {
           tag: '500',
           ind1: ' ',
           ind2: ' ',
-          subfields: [{code: 'a', value: 'FOO (Bar).'}]
+          subfields: [{code: 'a', value: 'FOO (Bar)'}]
+        }, {
+          tag: '500', // Range 500-509
+          ind1: ' ',
+          ind2: ' ',
+          subfields: [{code: 'a', value: '"Lorum ipsum.".'}]
+        },
+        {
+          tag: '500', // Range 500-509
+          ind1: ' ',
+          ind2: ' ',
+          subfields: [{code: 'a', value: 'Foo "Bar"'}]
         }
       ]
     });
@@ -77,24 +114,43 @@ describe('ending-punctuation', () => {
           ind1: ' ',
           ind2: ' ',
           subfields: [
-            {code: 'a', value: 'Elämäni ja tutkimusretkeni / '},
+            {code: 'a', value: 'Elämäni ja tutkimusretkeni /'},
             {code: 'c', value: 'Roald Amundsen ; suomentanut Sulo Veikko Pekkola'},
             {code: '6', value: 'FOO'}
           ]
+        }, { // Hackily putting 2nd 245 here
+          tag: '245',
+          ind1: '0',
+          ind2: '4',
+          subfields: [
+            {code: 'a', value: 'The Disaster /'},
+            {code: 'c', value: '(J.L.)'}
+          ]
         }, {
           tag: '337',
           ind1: ' ',
           ind2: ' ',
           subfields: [
             {code: 'a', value: 'käytettävissä ilman laitetta'},
-            {code: 'b', value: 'n'}, // Dot removed from possible abbreviation as it cannot be removed in fixing
+            {code: 'b', value: 'n'}, // Dot removed from possible abbreviation as it cannot be removed in fixing (NV: huh?)
             {code: '2', value: 'rdamedia'}
           ]
         }, {
           tag: '500',
           ind1: ' ',
           ind2: ' ',
-          subfields: [{code: 'a', value: 'FOO (Bar).'}]
+          subfields: [{code: 'a', value: 'FOO (Bar)'}]
+        }, {
+          tag: '500', // Range 500-509
+          ind1: ' ',
+          ind2: ' ',
+          subfields: [{code: 'a', value: '"Lorum ipsum.".'}]
+        },
+        {
+          tag: '500', // Range 500-509
+          ind1: ' ',
+          ind2: ' ',
+          subfields: [{code: 'a', value: 'Foo "Bar"'}]
         }
       ]
     });
@@ -102,14 +158,15 @@ describe('ending-punctuation', () => {
     it('Finds the record valid', async () => {
       const validator = await validatorFactory();
       const result = await validator.validate(recordValid);
-      expect(result.valid).to.eql(true);
+      //console.info(JSON.stringify(result));
+      assert.equal(result.valid, true);
     });
 
     it('Finds the record invalid', async () => {
       const validator = await validatorFactory();
       const result = await validator.validate(recordInvalid);
-      expect(result).to.eql({
-        message: ['Field 245 has invalid ending punctuation', 'Field 500 has invalid ending punctuation'],
+      assert.deepEqual(result, {
+        message: ['Field 245 requires ending punctuation, ends in \'a\'', 'Field 245 requires ending punctuation, ends in \')\'', 'Field 500 requires ending punctuation, ends in \')\'', 'Field 500 has an extra dot in \'.".\'', 'Field 500 requires ending punctuation, ends in \'"\''],
         valid: false
       });
     });
@@ -117,12 +174,13 @@ describe('ending-punctuation', () => {
     it('Repairs the invalid record', async () => {
       const validator = await validatorFactory();
       const result = await validator.fix(recordBroken);
-      expect(recordBroken.equalsTo(recordValid)).to.eql(true);
-      expect(result).to.eql({
-        message: ['Field 245 has invalid ending punctuation', 'Field 500 has invalid ending punctuation'],
-        fix: ['Field 245 - Added punctuation to $c', 'Field 500 - Removed double punctuation from $a'],
+
+      assert.deepEqual(result, {
+        message: ['Field 245 requires ending punctuation, ends in \'a\'', 'Field 245 requires ending punctuation, ends in \')\'', 'Field 500 requires ending punctuation, ends in \')\'', 'Field 500 has an extra dot in \'.".\'', 'Field 500 requires ending punctuation, ends in \'"\''],
+        fix: ['Field 245 - Added punctuation to $c', 'Field 245 - Added punctuation to $c', 'Field 500 - Added punctuation to $a', 'Field 500 - Removed \'.\' after \'."\'', 'Field 500 - Added punctuation to $a'],
         valid: false
       });
+      assert.equal(recordBroken.equalsTo(recordValid), true);
     });
   });
 
@@ -161,13 +219,13 @@ describe('ending-punctuation', () => {
       it('Finds record valid - Punc $b', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValid);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - Only $a without punc', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValidOnlyA);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       // Invalid tests
@@ -201,8 +259,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - No punc $b', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalid);
-        expect(result).to.eql({
-          message: ['Field 036 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 036 requires ending punctuation, ends in \'e\''],
           valid: false
         });
       });
@@ -210,8 +268,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - Only $a with punc', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalidOnlyA);
-        expect(result).to.eql({
-          message: ['Field 036 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 036 has unwanted ending punctuation \'.\''],
           valid: false
         });
       });
@@ -220,9 +278,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - Add punc $b', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalid);
-        expect(recordInvalid.equalsTo(recordValid)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 036 has invalid ending punctuation'],
+        assert.equal(recordInvalid.equalsTo(recordValid), true);
+        assert.deepEqual(result, {
+          message: ['Field 036 requires ending punctuation, ends in \'e\''],
           fix: ['Field 036 - Added punctuation to $b'],
           valid: false
         });
@@ -231,9 +289,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - Removes punc $a (register)', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalidOnlyA);
-        expect(recordInvalidOnlyA.equalsTo(recordValidOnlyA)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 036 has invalid ending punctuation'],
+        assert.equal(recordInvalidOnlyA.equalsTo(recordValidOnlyA), true);
+        assert.deepEqual(result, {
+          message: ['Field 036 has unwanted ending punctuation \'.\''],
           fix: ['Field 036 - Removed punctuation from $a'],
           valid: false
         });
@@ -291,19 +349,19 @@ describe('ending-punctuation', () => {
       it('Finds record valid - Punc $a', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValidOnlyA);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - Punc $p', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValidMultiple);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - Punc $a without $y', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValidWithoutY);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       // Invalid tests
@@ -385,8 +443,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - No punc at $a (only before $y)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalidOnlyAMissingA);
-        expect(result).to.eql({
-          message: ['Field 242 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 242 requires ending punctuation, ends in \'t\''],
           valid: false
         });
       });
@@ -394,8 +452,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - Punc at $y (Language field)', async () => { // $y is also checked as rule is explicit
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalidOnlyAPuncY);
-        expect(result).to.eql({
-          message: ['Field 242 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 242 has unwanted ending punctuation \'.\''],
           valid: false
         });
       });
@@ -403,8 +461,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - No punc at $a & punc $y', async () => { // $y is also checked as rule is explicit
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalidOnlyAMissingAPuncY);
-        expect(result).to.eql({
-          message: ['Field 242 has invalid ending punctuation', 'Field 242 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 242 has unwanted ending punctuation \'.\'', 'Field 242 requires ending punctuation, ends in \'t\''],
           valid: false
         });
       });
@@ -412,8 +470,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - No punc $p (last before $y)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValidMultipleMissingP);
-        expect(result).to.eql({
-          message: ['Field 242 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 242 requires ending punctuation, ends in \'y\''],
           valid: false
         });
       });
@@ -421,8 +479,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - No punc $a (only)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValidWithoutYMissingA);
-        expect(result).to.eql({
-          message: ['Field 242 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 242 requires ending punctuation, ends in \'t\''],
           valid: false
         });
       });
@@ -431,9 +489,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - Add punc $a', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalidOnlyAMissingA);
-        expect(recordInvalidOnlyAMissingA.equalsTo(recordValidOnlyA)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 242 has invalid ending punctuation'],
+        assert.equal(recordInvalidOnlyAMissingA.equalsTo(recordValidOnlyA), true);
+        assert.deepEqual(result, {
+          message: ['Field 242 requires ending punctuation, ends in \'t\''],
           fix: ['Field 242 - Added punctuation to $a'],
           valid: false
         });
@@ -442,9 +500,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - Remove punc $y (Language field)', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalidOnlyAPuncY);
-        expect(recordInvalidOnlyAPuncY.equalsTo(recordValidOnlyA)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 242 has invalid ending punctuation'],
+        assert.equal(recordInvalidOnlyAPuncY.equalsTo(recordValidOnlyA), true);
+        assert.deepEqual(result, {
+          message: ['Field 242 has unwanted ending punctuation \'.\''],
           fix: ['Field 242 - Removed punctuation from $y'],
           valid: false
         });
@@ -453,9 +511,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - Add punc $a & remove punc $y (Language field)', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalidOnlyAMissingAPuncY);
-        expect(recordInvalidOnlyAMissingAPuncY.equalsTo(recordValidOnlyA)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 242 has invalid ending punctuation', 'Field 242 has invalid ending punctuation'],
+        assert.equal(recordInvalidOnlyAMissingAPuncY.equalsTo(recordValidOnlyA), true);
+        assert.deepEqual(result, {
+          message: ['Field 242 has unwanted ending punctuation \'.\'', 'Field 242 requires ending punctuation, ends in \'t\''],
           fix: ['Field 242 - Removed punctuation from $y', 'Field 242 - Added punctuation to $a'],
           valid: false
         });
@@ -464,9 +522,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - Add punc $p', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordValidMultipleMissingP);
-        expect(recordValidMultipleMissingP.equalsTo(recordValidMultiple)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 242 has invalid ending punctuation'],
+        assert.equal(recordValidMultipleMissingP.equalsTo(recordValidMultiple), true);
+        assert.deepEqual(result, {
+          message: ['Field 242 requires ending punctuation, ends in \'y\''],
           fix: ['Field 242 - Added punctuation to $p'],
           valid: false
         });
@@ -475,9 +533,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - Add punc $a', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordValidWithoutYMissingA);
-        expect(recordValidWithoutYMissingA.equalsTo(recordValidWithoutY)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 242 has invalid ending punctuation'],
+        assert.equal(recordValidWithoutYMissingA.equalsTo(recordValidWithoutY), true);
+        assert.deepEqual(result, {
+          message: ['Field 242 requires ending punctuation, ends in \'t\''],
           fix: ['Field 242 - Added punctuation to $a'],
           valid: false
         });
@@ -540,19 +598,19 @@ describe('ending-punctuation', () => {
       it('Finds record valid - Punc $c', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValidEndC);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - Punc char $g (after $c)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValidEndG);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - No punc $b', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValidEndB);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       // Invalid tests
@@ -592,8 +650,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalidEndC);
-        expect(result).to.eql({
-          message: ['Field 260 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 260 requires ending punctuation, ends in \'2\''],
           valid: false
         });
       });
@@ -601,8 +659,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalidEndGDouble);
-        expect(result).to.eql({
-          message: ['Field 260 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 260 has an extra dot after \')\''],
           valid: false
         });
       });
@@ -611,9 +669,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - Add punc $c', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalidEndC);
-        expect(recordInvalidEndC.equalsTo(recordValidEndC)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 260 has invalid ending punctuation'],
+        assert.equal(recordInvalidEndC.equalsTo(recordValidEndC), true);
+        assert.deepEqual(result, {
+          message: ['Field 260 requires ending punctuation, ends in \'2\''],
           fix: ['Field 260 - Added punctuation to $c'],
           valid: false
         });
@@ -622,10 +680,10 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - Remove double punc $g', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalidEndGDouble);
-        expect(recordInvalidEndGDouble.equalsTo(recordValidEndG)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 260 has invalid ending punctuation'],
-          fix: ['Field 260 - Removed double punctuation from $g'],
+        assert.equal(recordInvalidEndGDouble.equalsTo(recordValidEndG), true);
+        assert.deepEqual(result, {
+          message: ['Field 260 has an extra dot after \')\''],
+          fix: ['Field 260 - Removed dot after punctuation from $g'],
           valid: false
         });
       });
@@ -711,25 +769,25 @@ describe('ending-punctuation', () => {
       it('Finds record valid - Ind2 = 1, $c 1995-2006.', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValidInd2v1);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - Ind2 = 1, $c 1995-', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValidInd2v1Short);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - Ind2 = 2, no $c', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValidInd2v2WithoutC);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - Ind2 = 4, copyright', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValidCopyright);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       const recordInvalidInd2v1 = new MarcRecord({
@@ -767,8 +825,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - No punc $c', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalidInd2v1);
-        expect(result).to.eql({
-          message: ['Field 264 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 264 requires ending punctuation, ends in \'6\''],
           valid: false
         });
       });
@@ -776,8 +834,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - Ind2 = 4, copyright, extra punc $c', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalidCopyrightCExtra);
-        expect(result).to.eql({
-          message: ['Field 264 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 264 has unwanted ending punctuation \'.\''],
           valid: false
         });
       });
@@ -786,9 +844,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - Add punc $c', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalidInd2v1);
-        expect(recordInvalidInd2v1.equalsTo(recordValidInd2v1)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 264 has invalid ending punctuation'],
+        assert.equal(recordInvalidInd2v1.equalsTo(recordValidInd2v1), true);
+        assert.deepEqual(result, {
+          message: ['Field 264 requires ending punctuation, ends in \'6\''],
           fix: ['Field 264 - Added punctuation to $c'],
           valid: false
         });
@@ -797,9 +855,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - Remove punc $c ($c has ©, should not have punc)', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalidCopyrightCExtra);
-        expect(recordInvalidCopyrightCExtra.equalsTo(recordValidCopyright)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 264 has invalid ending punctuation'],
+        assert.equal(recordInvalidCopyrightCExtra.equalsTo(recordValidCopyright), true);
+        assert.deepEqual(result, {
+          message: ['Field 264 has unwanted ending punctuation \'.\''],
           fix: ['Field 264 - Removed punctuation from $c'],
           valid: false
         });
@@ -891,31 +949,31 @@ describe('ending-punctuation', () => {
       it('Finds record valid - Punc $a (only)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValidA);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - Punc $a (last) & punc $b (mandatory)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValidAB);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - Punc $d (last of two)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValidDD);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - Punc $d (last of two) followed by $g', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValidComplex);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - No punc (not $b, nor from list)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValidJ2);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       // Invalid tests
@@ -998,8 +1056,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - No punc $a (only)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalidA);
-        expect(result).to.eql({
-          message: ['Field 340 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 340 requires ending punctuation, ends in \'e\''],
           valid: false
         });
       });
@@ -1007,8 +1065,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - No punc $a (last)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalidAMissingB);
-        expect(result).to.eql({
-          message: ['Field 340 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 340 requires ending punctuation, ends in \'t\''],
           valid: false
         });
       });
@@ -1016,8 +1074,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - No punc $b (mandatory)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalidABMissing);
-        expect(result).to.eql({
-          message: ['Field 340 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 340 requires ending punctuation, ends in \'m\''],
           valid: false
         });
       });
@@ -1025,8 +1083,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - No punc $d (last of two)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalidDDMissing);
-        expect(result).to.eql({
-          message: ['Field 340 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 340 requires ending punctuation, ends in \'d\''],
           valid: false
         });
       });
@@ -1034,8 +1092,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - No punc $d (last of two) followed by $g', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalidComplexDMissing);
-        expect(result).to.eql({
-          message: ['Field 340 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 340 requires ending punctuation, ends in \'e\''],
           valid: false
         });
       });
@@ -1044,9 +1102,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - Add punc $a (only)', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalidA);
-        expect(recordInvalidA.equalsTo(recordInvalidA)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 340 has invalid ending punctuation'],
+        assert.equal(recordInvalidA.equalsTo(recordInvalidA), true);
+        assert.deepEqual(result, {
+          message: ['Field 340 requires ending punctuation, ends in \'e\''],
           fix: ['Field 340 - Added punctuation to $a'],
           valid: false
         });
@@ -1055,9 +1113,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - Add punc $a (last)', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalidAMissingB);
-        expect(recordInvalidAMissingB.equalsTo(recordValidAB)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 340 has invalid ending punctuation'],
+        assert.equal(recordInvalidAMissingB.equalsTo(recordValidAB), true);
+        assert.deepEqual(result, {
+          message: ['Field 340 requires ending punctuation, ends in \'t\''],
           fix: ['Field 340 - Added punctuation to $a'],
           valid: false
         });
@@ -1066,9 +1124,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - Add punc $b (mandatory)', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalidABMissing);
-        expect(recordInvalidABMissing.equalsTo(recordValidAB)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 340 has invalid ending punctuation'],
+        assert.equal(recordInvalidABMissing.equalsTo(recordValidAB), true);
+        assert.deepEqual(result, {
+          message: ['Field 340 requires ending punctuation, ends in \'m\''],
           fix: ['Field 340 - Added punctuation to $b'],
           valid: false
         });
@@ -1077,9 +1135,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - Add punc $d (last of two)', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalidDDMissing);
-        expect(recordInvalidDDMissing.equalsTo(recordValidDD)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 340 has invalid ending punctuation'],
+        assert.equal(recordInvalidDDMissing.equalsTo(recordValidDD), true);
+        assert.deepEqual(result, {
+          message: ['Field 340 requires ending punctuation, ends in \'d\''],
           fix: ['Field 340 - Added punctuation to $d'],
           valid: false
         });
@@ -1088,9 +1146,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - Add punc $d (last of list)', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalidComplexDMissing);
-        expect(recordInvalidComplexDMissing.equalsTo(recordInvalidComplexDMissing)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 340 has invalid ending punctuation'],
+        assert.equal(recordInvalidComplexDMissing.equalsTo(recordInvalidComplexDMissing), true);
+        assert.deepEqual(result, {
+          message: ['Field 340 requires ending punctuation, ends in \'e\''],
           fix: ['Field 340 - Added punctuation to $d'],
           valid: false
         });
@@ -1145,19 +1203,19 @@ describe('ending-punctuation', () => {
       it('Finds record valid - Punc $a (without $u)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValid);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - Punc $a (with $u) ', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValidWithU);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - Punc $a & $u (punc at $u should be ignored) ', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValidU);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       // Invalid tests
@@ -1191,8 +1249,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - No punc $a (without $u)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalid);
-        expect(result).to.eql({
-          message: ['Field 520 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 520 requires ending punctuation, ends in \'ö\''],
           valid: false
         });
       });
@@ -1200,8 +1258,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - No punc $a (with $u)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalidWithU);
-        expect(result).to.eql({
-          message: ['Field 520 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 520 requires ending punctuation, ends in \'i\''],
           valid: false
         });
       });
@@ -1210,9 +1268,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - Add punc $a (only)', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalid);
-        expect(recordInvalid.equalsTo(recordValid)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 520 has invalid ending punctuation'],
+        assert.equal(recordInvalid.equalsTo(recordValid), true);
+        assert.deepEqual(result, {
+          message: ['Field 520 requires ending punctuation, ends in \'ö\''],
           fix: ['Field 520 - Added punctuation to $a'],
           valid: false
         });
@@ -1221,9 +1279,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - Add punc $a (last before $u)', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalidWithU);
-        expect(recordInvalidWithU.equalsTo(recordValidWithU)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 520 has invalid ending punctuation'],
+        assert.equal(recordInvalidWithU.equalsTo(recordValidWithU), true);
+        assert.deepEqual(result, {
+          message: ['Field 520 requires ending punctuation, ends in \'i\''],
           fix: ['Field 520 - Added punctuation to $a'],
           valid: false
         });
@@ -1282,19 +1340,19 @@ describe('ending-punctuation', () => {
       it('Finds record valid - Punc $i (last before $u)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValid);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - Punc $i & punc $u ($u is URL, should pass)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValidPuncU);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - Punc $a (only)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValidOnlyA);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       // Invalid tests
@@ -1345,8 +1403,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - No punc $i (last before $u)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalidMissingI);
-        expect(result).to.eql({
-          message: ['Field 538 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 538 requires ending punctuation, ends in \'s\''],
           valid: false
         });
       });
@@ -1354,8 +1412,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - Invalid punc $i (":" not valid punc mark, but this is according example...)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalidI);
-        expect(result).to.eql({
-          message: ['Field 538 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 538 requires ending punctuation, ends in \':\''],
           valid: false
         });
       });
@@ -1363,8 +1421,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - No punc $a (only)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalidOnlyA);
-        expect(result).to.eql({
-          message: ['Field 538 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 538 requires ending punctuation, ends in \'e\''],
           valid: false
         });
       });
@@ -1373,9 +1431,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - Add punc $i (last)', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalidMissingI);
-        expect(recordInvalidMissingI.equalsTo(recordValid)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 538 has invalid ending punctuation'],
+        assert.equal(recordInvalidMissingI.equalsTo(recordValid), true);
+        assert.deepEqual(result, {
+          message: ['Field 538 requires ending punctuation, ends in \'s\''],
           fix: ['Field 538 - Added punctuation to $i'],
           valid: false
         });
@@ -1384,9 +1442,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - Add punc $a (only)', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalidOnlyA);
-        expect(recordInvalidOnlyA.equalsTo(recordValidOnlyA)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 538 has invalid ending punctuation'],
+        assert.equal(recordInvalidOnlyA.equalsTo(recordValidOnlyA), true);
+        assert.deepEqual(result, {
+          message: ['Field 538 requires ending punctuation, ends in \'e\''],
           fix: ['Field 538 - Added punctuation to $a'],
           valid: false
         });
@@ -1427,13 +1485,13 @@ describe('ending-punctuation', () => {
       it('Finds record valid - Punc $a (only)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValid);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - No punc $b (only data field)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValidWithoutA);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       // Invalid tests
@@ -1467,8 +1525,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - No punc $a (only)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalid);
-        expect(result).to.eql({
-          message: ['Field 567 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 567 requires ending punctuation, ends in \'s\''],
           valid: false
         });
       });
@@ -1476,8 +1534,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - Punc $b (only data field)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalidWithoutA);
-        expect(result).to.eql({
-          message: ['Field 567 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 567 has unwanted ending punctuation \'.\''],
           valid: false
         });
       });
@@ -1486,9 +1544,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - Add punc $a (only)', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalid);
-        expect(recordInvalid.equalsTo(recordValid)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 567 has invalid ending punctuation'],
+        assert.equal(recordInvalid.equalsTo(recordValid), true);
+        assert.deepEqual(result, {
+          message: ['Field 567 requires ending punctuation, ends in \'s\''],
           fix: ['Field 567 - Added punctuation to $a'],
           valid: false
         });
@@ -1497,9 +1555,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - Remove punc $b (only data field)', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalidWithoutA);
-        expect(recordInvalidWithoutA.equalsTo(recordValidWithoutA)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 567 has invalid ending punctuation'],
+        assert.equal(recordInvalidWithoutA.equalsTo(recordValidWithoutA), true);
+        assert.deepEqual(result, {
+          message: ['Field 567 has unwanted ending punctuation \'.\''],
           fix: ['Field 567 - Removed punctuation from $b'],
           valid: false
         });
@@ -1527,7 +1585,7 @@ describe('ending-punctuation', () => {
         ]
       });
 
-      const recordVali648dFinNo = new MarcRecord({
+      const recordValid648FinNo = new MarcRecord({
         leader: '',
         fields: [
           {
@@ -1538,6 +1596,16 @@ describe('ending-punctuation', () => {
               {code: 'a', value: '1900-luku'},
               {code: '2', value: 'yso/swe'}
             ]
+          },
+          { // Exception: term ending in dot:
+            tag : '648',
+            ind1: ' ',
+            ind2: '7',
+            subfields: [
+              {code: 'a', value: '1200-luku eaa.'},
+              {code: '2', value: 'yso/fin'},
+              {code: '0', value: 'http://www.yso.fi/onto/yso/p1129911200'}
+            ]
           }
         ]
       });
@@ -1605,37 +1673,37 @@ describe('ending-punctuation', () => {
       it('Finds record valid - 647 Fast, punc char at end', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValid647FastEndPunc);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - 648 Finnish, without punc', async () => {
         const validator = await validatorFactory();
-        const result = await validator.validate(recordVali648dFinNo);
-        expect(result.valid).to.eql(true);
+        const result = await validator.validate(recordValid648FinNo);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - 648 Fast, without punc', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValid648FastNo);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - 650 Finnish, without punc', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValid650FinNo);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - 650 English, punc (no control)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValid650EngNoControl);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - 650 English, with punc', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValid650EngControl);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       // Invalid tests
@@ -1655,7 +1723,7 @@ describe('ending-punctuation', () => {
         ]
       });
 
-      const recordInvali648dFinYes = new MarcRecord({
+      const recordInvalid648FinYes = new MarcRecord({
         leader: '',
         fields: [
           {
@@ -1666,6 +1734,15 @@ describe('ending-punctuation', () => {
               {code: 'a', value: '1900-luku.'},
               {code: '2', value: 'yso/swe'}
             ]
+          }, { // Exception:
+            tag: '648',
+            ind1: ' ',
+            ind2: '7',
+            subfields: [
+              {code: 'a', value: '1200-luku eaa'},
+              {code: '2', value: 'yso/fin'},
+              {code: '0', value: 'http://www.yso.fi/onto/yso/p1129911200'}
+            ]
           }
         ]
       });
@@ -1733,17 +1810,17 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - 647 Fast, dot at end', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalid647FastEndPunc);
-        expect(result).to.eql({
-          message: ['Field 647 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 647 has an extra dot after \')\''],
           valid: false
         });
       });
 
       it('Finds record invalid - 648 Finnish, with punc', async () => {
         const validator = await validatorFactory();
-        const result = await validator.validate(recordInvali648dFinYes);
-        expect(result).to.eql({
-          message: ['Field 648 has invalid ending punctuation'],
+        const result = await validator.validate(recordInvalid648FinYes);
+        assert.deepEqual(result, {
+          message: ['Field 648 has unwanted ending punctuation \'.\'', "Field 648 requires ending punctuation, ends in 'a'"],
           valid: false
         });
       });
@@ -1751,17 +1828,17 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - 648 Fast, with punc', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalid648FastYes);
-        expect(result).to.eql({
-          message: ['Field 648 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 648 has unwanted ending punctuation \'.\''],
           valid: false
         });
       });
 
-      const invalidField650Message = 'Field 650 has invalid ending punctuation';
+      const invalidField650Message = 'Field 650 has unwanted ending punctuation \'.\'';
       it('Finds record invalid - 650 Finnish, with punc', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalid650FinYes);
-        expect(result).to.eql({
+        assert.deepEqual(result, {
           message: [invalidField650Message, invalidField650Message],
           valid: false
         });
@@ -1770,8 +1847,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - 650 !Finnish, without punc (no control)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalid650EngNoControl);
-        expect(result).to.eql({
-          message: [invalidField650Message],
+        assert.deepEqual(result, {
+          message: ['Field 650 requires ending punctuation, ends in \'s\''],
           valid: false
         });
       });
@@ -1779,8 +1856,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - 650 !Finnish, without punc', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalid650EngControl);
-        expect(result).to.eql({
-          message: ['Field 650 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 650 requires ending punctuation, ends in \'n\''],
           valid: false
         });
       });
@@ -1789,21 +1866,26 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - 647 Fast, removes double punc $d', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalid647FastEndPunc);
-        expect(recordInvalid647FastEndPunc.equalsTo(recordValid647FastEndPunc)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 647 has invalid ending punctuation'],
-          fix: ['Field 647 - Removed double punctuation from $d'],
+        assert.equal(recordInvalid647FastEndPunc.equalsTo(recordValid647FastEndPunc), true);
+        assert.deepEqual(result, {
+          message: ['Field 647 has an extra dot after \')\''],
+          fix: ['Field 647 - Removed dot after punctuation from $d'],
           valid: false
         });
       });
 
       it('Repairs the invalid record - 648 Finnish, removes punc $a', async () => {
         const validator = await validatorFactory();
-        const result = await validator.fix(recordInvali648dFinYes);
-        expect(recordInvali648dFinYes.equalsTo(recordVali648dFinNo)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 648 has invalid ending punctuation'],
-          fix: ['Field 648 - Removed punctuation from $a'],
+        const result = await validator.fix(recordInvalid648FinYes);
+        //console.info("NV-------");
+        //console.info(JSON.stringify(recordInvalid648FinYes));
+        //console.info(JSON.stringify(recordValid648FinNo));
+        //assert.equal(recordInvalid648FinYes.equalsTo(recordValid648FinNo), true);
+        assert.deepEqual(recordInvalid648FinYes, recordValid648FinNo);
+        //console.info(JSON.stringify(result));
+        assert.deepEqual(result, {
+          message: ['Field 648 has unwanted ending punctuation \'.\'', "Field 648 requires ending punctuation, ends in 'a'"],
+          fix: ['Field 648 - Removed punctuation from $a', 'Field 648 - Added punctuation to $a'],
           valid: false
         });
       });
@@ -1811,9 +1893,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - 648 Fast, removes punc $a', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalid648FastYes);
-        expect(recordInvalid648FastYes.equalsTo(recordValid648FastNo)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 648 has invalid ending punctuation'],
+        assert.equal(recordInvalid648FastYes.equalsTo(recordValid648FastNo), true);
+        assert.deepEqual(result, {
+          message: ['Field 648 has unwanted ending punctuation \'.\''],
           fix: ['Field 648 - Removed punctuation from $a'],
           valid: false
         });
@@ -1822,8 +1904,8 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - 650 Finnish, removes punc $x', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalid650FinYes);
-        expect(recordInvalid650FinYes.equalsTo(recordValid650FinNo)).to.eql(true);
-        expect(result).to.eql({
+        assert.equal(recordInvalid650FinYes.equalsTo(recordValid650FinNo), true);
+        assert.deepEqual(result, {
           message: [invalidField650Message, invalidField650Message],
           fix: ['Field 650 - Removed punctuation from $x', 'Field 650 - Removed punctuation from $a'],
           valid: false
@@ -1833,9 +1915,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - 650 !Finnish, add punc $v (no control)', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalid650EngNoControl);
-        expect(recordInvalid650EngNoControl.equalsTo(recordValid650EngNoControl)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 650 has invalid ending punctuation'],
+        assert.equal(recordInvalid650EngNoControl.equalsTo(recordValid650EngNoControl), true);
+        assert.deepEqual(result, {
+          message: ['Field 650 requires ending punctuation, ends in \'s\''],
           fix: ['Field 650 - Added punctuation to $v'],
           valid: false
         });
@@ -1844,9 +1926,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - 650 !Finnish, add punc $a', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalid650EngControl);
-        expect(recordInvalid650EngControl.equalsTo(recordValid650EngControl)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 650 has invalid ending punctuation'],
+        assert.equal(recordInvalid650EngControl.equalsTo(recordValid650EngControl), true);
+        assert.deepEqual(result, {
+          message: ['Field 650 requires ending punctuation, ends in \'n\''],
           fix: ['Field 650 - Added punctuation to $a'],
           valid: false
         });
@@ -1856,7 +1938,7 @@ describe('ending-punctuation', () => {
     // "654-662 EI - EI suomalaisten sanastojen termeihin, muihin sanaston käytännön mukaan, yleensä KYLLÄ"
     // Finnish terms at $2:['ysa', 'yso', 'kassu', 'seko', 'valo', 'kulo', 'puho', 'oiko', 'mero', 'liito', 'fast', 'allars']
     // Default TRUE, until more special cases are added
-    describe('#654-662 TRUE - If finnish, else TRUE', () => {
+    describe('#654-662 TRUE - If Finnish, else TRUE', () => {
       // Valid tests
       const recordValid655FinNo = new MarcRecord({
         leader: '',
@@ -1982,49 +2064,49 @@ describe('ending-punctuation', () => {
       it('Finds record valid - 655 Finnish, no punc $a', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValid655FinNo);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - 655 Finnish, without punc', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValid655FinNo2);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - 655 English, with punc $y', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValid655EngYes);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - 655 English, with punc $a (no control)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValid655EngYesNoControl);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - 656 Finnish, without punc $a', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValid656FinNo);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - 657 English, with punc $z', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValid657EngYes);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - 658 English, with punc $d', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValid658EngYes);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - 662 English, with punc $a', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValid662EngYes);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       // Invalid tests
@@ -2152,8 +2234,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - 655 Finnish, punc $a', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalid655FinYes);
-        expect(result).to.eql({
-          message: ['Field 655 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 655 has unwanted ending punctuation \'.\''],
           valid: false
         });
       });
@@ -2161,8 +2243,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - 655 Finnish, with punc', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalid655FinYes2);
-        expect(result).to.eql({
-          message: ['Field 655 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 655 has unwanted ending punctuation \'.\''],
           valid: false
         });
       });
@@ -2170,8 +2252,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - 655 !Finnish, without punc $y', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalid655EngNo);
-        expect(result).to.eql({
-          message: ['Field 655 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 655 requires ending punctuation, ends in \'4\''],
           valid: false
         });
       });
@@ -2179,8 +2261,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - 655 !Finnish, without punc $a (no control)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalid655EngNoNoControl);
-        expect(result).to.eql({
-          message: ['Field 655 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 655 requires ending punctuation, ends in \'s\''],
           valid: false
         });
       });
@@ -2188,8 +2270,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - 656 Finnish, with punc $a', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalid656FinYes);
-        expect(result).to.eql({
-          message: ['Field 656 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 656 has unwanted ending punctuation \'.\''],
           valid: false
         });
       });
@@ -2197,8 +2279,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - 657 !Finnish, without punc $z', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalid657EngNo);
-        expect(result).to.eql({
-          message: ['Field 657 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 657 requires ending punctuation, ends in \'k\''],
           valid: false
         });
       });
@@ -2206,8 +2288,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - 658 !Finnish, without punc $d', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalid658EngNo);
-        expect(result).to.eql({
-          message: ['Field 658 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 658 requires ending punctuation, ends in \'d\''],
           valid: false
         });
       });
@@ -2215,8 +2297,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - 662 !Finnish, without punc $a', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalid662EngNo);
-        expect(result).to.eql({
-          message: ['Field 662 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 662 requires ending punctuation, ends in \'a\''],
           valid: false
         });
       });
@@ -2225,9 +2307,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - 655 Finnish, remove punc $a', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalid655FinYes);
-        expect(recordInvalid655FinYes.equalsTo(recordValid655FinNo)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 655 has invalid ending punctuation'],
+        assert.equal(recordInvalid655FinYes.equalsTo(recordValid655FinNo), true);
+        assert.deepEqual(result, {
+          message: ['Field 655 has unwanted ending punctuation \'.\''],
           fix: ['Field 655 - Removed punctuation from $a'],
           valid: false
         });
@@ -2236,9 +2318,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - 655 Finnish, removes punc $a 2', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalid655FinYes2);
-        expect(recordInvalid655FinYes2.equalsTo(recordValid655FinNo2)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 655 has invalid ending punctuation'],
+        assert.equal(recordInvalid655FinYes2.equalsTo(recordValid655FinNo2), true);
+        assert.deepEqual(result, {
+          message: ['Field 655 has unwanted ending punctuation \'.\''],
           fix: ['Field 655 - Removed punctuation from $a'],
           valid: false
         });
@@ -2247,9 +2329,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - 655 !Finnish, add punc $y', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalid655EngNo);
-        expect(recordInvalid655EngNo.equalsTo(recordValid655EngYes)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 655 has invalid ending punctuation'],
+        assert.equal(recordInvalid655EngNo.equalsTo(recordValid655EngYes), true);
+        assert.deepEqual(result, {
+          message: ['Field 655 requires ending punctuation, ends in \'4\''],
           fix: ['Field 655 - Added punctuation to $y'],
           valid: false
         });
@@ -2258,9 +2340,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - 655 !Finnish, add punc $a (no control)', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalid655EngNoNoControl);
-        expect(recordInvalid655EngNoNoControl.equalsTo(recordValid655EngYesNoControl)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 655 has invalid ending punctuation'],
+        assert.equal(recordInvalid655EngNoNoControl.equalsTo(recordValid655EngYesNoControl), true);
+        assert.deepEqual(result, {
+          message: ['Field 655 requires ending punctuation, ends in \'s\''],
           fix: ['Field 655 - Added punctuation to $a'],
           valid: false
         });
@@ -2269,9 +2351,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - 656 Finnish, remove punc $a', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalid656FinYes);
-        expect(recordInvalid656FinYes.equalsTo(recordValid656FinNo)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 656 has invalid ending punctuation'],
+        assert.equal(recordInvalid656FinYes.equalsTo(recordValid656FinNo), true);
+        assert.deepEqual(result, {
+          message: ['Field 656 has unwanted ending punctuation \'.\''],
           fix: ['Field 656 - Removed punctuation from $a'],
           valid: false
         });
@@ -2280,9 +2362,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - 657 !Finnish, add punc $z', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalid657EngNo);
-        expect(recordInvalid657EngNo.equalsTo(recordValid657EngYes)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 657 has invalid ending punctuation'],
+        assert.equal(recordInvalid657EngNo.equalsTo(recordValid657EngYes), true);
+        assert.deepEqual(result, {
+          message: ['Field 657 requires ending punctuation, ends in \'k\''],
           fix: ['Field 657 - Added punctuation to $z'],
           valid: false
         });
@@ -2291,20 +2373,20 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - 658 !Finnish, add punc $d', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalid658EngNo);
-        expect(recordInvalid658EngNo.equalsTo(recordValid658EngYes)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 658 has invalid ending punctuation'],
+        assert.equal(recordInvalid658EngNo.equalsTo(recordValid658EngYes), true);
+        assert.deepEqual(result, {
+          message: ['Field 658 requires ending punctuation, ends in \'d\''],
           fix: ['Field 658 - Added punctuation to $d'],
           valid: false
         });
       });
 
-      it('Repairs the invalid record - 662 !Finnish, add pun $a', async () => {
+      it('Repairs the invalid record - 662 !Finnish, add punc $a', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalid662EngNo);
-        expect(recordInvalid662EngNo.equalsTo(recordValid662EngYes)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 662 has invalid ending punctuation'],
+        assert.equal(recordInvalid662EngNo.equalsTo(recordValid662EngYes), true);
+        assert.deepEqual(result, {
+          message: ['Field 662 requires ending punctuation, ends in \'a\''],
           fix: ['Field 662 - Added punctuation to $a'],
           valid: false
         });
@@ -2346,13 +2428,13 @@ describe('ending-punctuation', () => {
       it('Finds record valid - Punc $a, but following fields, $e no punc (last)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValid);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - Punc $a (only)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValidOnlyA);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       // Invalid tests
@@ -2387,8 +2469,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - Punc $e (language field, strict)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalid);
-        expect(result).to.eql({
-          message: ['Field 760 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 760 has unwanted ending punctuation \'.\''],
           valid: false
         });
       });
@@ -2396,8 +2478,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - No punc $a (only)', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalidOnlyA);
-        expect(result).to.eql({
-          message: ['Field 760 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 760 requires ending punctuation, ends in \'c\''],
           valid: false
         });
       });
@@ -2406,9 +2488,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - Remove punc $e (language field, strict)', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalid);
-        expect(recordInvalid.equalsTo(recordValid)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 760 has invalid ending punctuation'],
+        assert.equal(recordInvalid.equalsTo(recordValid), true);
+        assert.deepEqual(result, {
+          message: ['Field 760 has unwanted ending punctuation \'.\''],
           fix: ['Field 760 - Removed punctuation from $e'],
           valid: false
         });
@@ -2417,9 +2499,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - Add punc $a (only)', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalidOnlyA);
-        expect(recordInvalidOnlyA.equalsTo(recordValidOnlyA)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 760 has invalid ending punctuation'],
+        assert.equal(recordInvalidOnlyA.equalsTo(recordValidOnlyA), true);
+        assert.deepEqual(result, {
+          message: ['Field 760 requires ending punctuation, ends in \'c\''],
           fix: ['Field 760 - Added punctuation to $a'],
           valid: false
         });
@@ -2467,13 +2549,13 @@ describe('ending-punctuation', () => {
       it('Finds record valid - Punc $b', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValidSimple);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       it('Finds record valid - Punc $c', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordValidComplex);
-        expect(result.valid).to.eql(true);
+        assert.equal(result.valid, true);
       });
 
       // Invalid tests
@@ -2513,8 +2595,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - No punc $b', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalidSimple);
-        expect(result).to.eql({
-          message: ['Field 880 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 880 requires ending punctuation, ends in \'3\''],
           valid: false
         });
       });
@@ -2522,8 +2604,8 @@ describe('ending-punctuation', () => {
       it('Finds record invalid - No punc $c', async () => {
         const validator = await validatorFactory();
         const result = await validator.validate(recordInvalidComplex);
-        expect(result).to.eql({
-          message: ['Field 880 has invalid ending punctuation'],
+        assert.deepEqual(result, {
+          message: ['Field 880 requires ending punctuation, ends in \'6\''],
           valid: false
         });
       });
@@ -2532,9 +2614,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - Add punc $b', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalidSimple);
-        expect(recordInvalidSimple.equalsTo(recordValidSimple)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 880 has invalid ending punctuation'],
+        assert.equal(recordInvalidSimple.equalsTo(recordValidSimple), true);
+        assert.deepEqual(result, {
+          message: ['Field 880 requires ending punctuation, ends in \'3\''],
           fix: ['Field 880 - Added punctuation to $b'],
           valid: false
         });
@@ -2543,9 +2625,9 @@ describe('ending-punctuation', () => {
       it('Repairs the invalid record - Add punc $c', async () => {
         const validator = await validatorFactory();
         const result = await validator.fix(recordInvalidComplex);
-        expect(recordInvalidComplex.equalsTo(recordValidComplex)).to.eql(true);
-        expect(result).to.eql({
-          message: ['Field 880 has invalid ending punctuation'],
+        assert.equal(recordInvalidComplex.equalsTo(recordValidComplex), true);
+        assert.deepEqual(result, {
+          message: ['Field 880 requires ending punctuation, ends in \'6\''],
           fix: ['Field 880 - Added punctuation to $c'],
           valid: false
         });