@natlibfi/marc-record-validators-melinda 8.4.5 → 9.0.0

package/src/field-exclusion.spec.js

@@ -314,20 +314,20 @@ describe('field-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: []});
+      const {valid, message} = await validator.validate(recordValid);
+      expect({valid, message}).to.eql({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: ['Field $500 should be excluded']});
+      const {valid, message} = await validator.validate(recordInvalid);
+      expect({valid, message}).to.eql({valid: false, message: ['Field $500 should be excluded']});
     });
 
     it('Finds the record invalid - double', async () => {
       const validator = await validatorFactory(config);
-      const result = await validator.validate(recordInvalidDouble);
-      expect(result).to.eql({valid: false, message: ['Field $500 should be excluded', 'Field $500 should be excluded']});
+      const {valid, message} = await validator.validate(recordInvalidDouble);
+      expect({valid, message}).to.eql({valid: false, message: ['Field $500 should be excluded', 'Field $500 should be excluded']});
     });
 
     it('Repairs invalid record', async () => {
@@ -425,20 +425,20 @@ describe('field-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: []});
+      const {valid, message} = await validator.validate(recordValid);
+      expect({valid, message}).to.eql({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: ['Field $648 should be excluded']});
+      const {valid, message} = await validator.validate(recordInvalid);
+      expect({valid, message}).to.eql({valid: false, message: ['Field $648 should be excluded']});
     });
 
     it('Finds the record invalid - double', async () => {
       const validator = await validatorFactory(config);
-      const result = await validator.validate(recordInvalidDouble);
-      expect(result).to.eql({valid: false, message: ['Field $648 should be excluded', 'Field $650 should be excluded']});
+      const {valid, message} = await validator.validate(recordInvalidDouble);
+      expect({valid, message}).to.eql({valid: false, message: ['Field $648 should be excluded', 'Field $650 should be excluded']});
     });
 
     it('Repairs invalid record', async () => {
@@ -454,6 +454,114 @@ describe('field-exclusion', () => {
     });
   });
 
+  // Simple multi tag configuration
+  describe('#validate: Simple multi tag configuration - No object (spec)', () => {
+    const config = [/^(648|650|651|655)$/u]; // eslint-disable-line prefer-named-capture-group
+
+    const recordValid = new MarcRecord({
+      leader: 'foo',
+      fields: [
+        {
+          tag: '245',
+          ind1: ' ',
+          ind2: ' ',
+          subfields: [{code: 'a', value: 'Fubar'}]
+        }
+      ]
+    });
+
+    const recordInvalid = new MarcRecord({
+      leader: 'foo',
+      fields: [
+        {
+          tag: '245',
+          ind1: ' ',
+          ind2: ' ',
+          subfields: [{code: 'a', value: 'Fubar'}]
+        }, {
+          tag: '648',
+          ind1: ' ',
+          ind2: ' ',
+          subfields: [
+            {code: 'a', value: 'Foo Bar Foo Bar Foo Bar'},
+            {code: '9', value: 'ALMA<KEEP>'}
+          ]
+        }
+      ]
+    });
+
+    const recordInvalidDouble = new MarcRecord({
+      leader: 'foo',
+      fields: [
+        {
+          tag: '245',
+          ind1: ' ',
+          ind2: ' ',
+          subfields: [{code: 'a', value: 'Fubar'}]
+        }, {
+          tag: '648',
+          ind1: ' ',
+          ind2: ' ',
+          subfields: [
+            {code: 'a', value: 'Foo'},
+            {code: '9', value: 'ALMA<KEEP>'}
+          ]
+        }, {
+          tag: '650',
+          ind1: ' ',
+          ind2: ' ',
+          subfields: [
+            {code: 'a', value: 'Bar'},
+            {code: '9', value: 'ALMA<KEEP>'}
+          ]
+        }
+      ]
+    });
+
+    const recordInvalidFixed = new MarcRecord({
+      leader: 'foo',
+      fields: [
+        {
+          tag: '245',
+          ind1: ' ',
+          ind2: ' ',
+          subfields: [{code: 'a', value: 'Fubar'}]
+        }
+      ]
+    });
+
+    it('Finds the record valid (spec)', async () => {
+      const validator = await validatorFactory(config);
+      const {valid, message} = await validator.validate(recordValid);
+      expect({valid, message}).to.eql({valid: true, message: []});
+    });
+
+    it('Finds the record invalid (spec)', async () => {
+      const validator = await validatorFactory(config);
+      const {valid, message} = await validator.validate(recordInvalid);
+      expect({valid, message}).to.eql({valid: false, message: ['Field $648 should be excluded']});
+    });
+
+    it('Finds the record invalid - double', async () => {
+      const validator = await validatorFactory(config);
+      const {valid, message} = await validator.validate(recordInvalidDouble);
+      expect({valid, message}).to.eql({valid: false, message: ['Field $648 should be excluded', 'Field $650 should be excluded']});
+    });
+
+    it('Repairs invalid record', async () => {
+      const validator = await validatorFactory(config);
+      await validator.fix(recordInvalid);
+      expect(recordInvalid.equalsTo(recordInvalidFixed)).to.eql(true);
+    });
+
+    it('Repairs invalid record - double', async () => {
+      const validator = await validatorFactory(config);
+      await validator.fix(recordInvalidDouble);
+      expect(recordInvalidDouble.equalsTo(recordInvalidFixed)).to.eql(true);
+    });
+  });
+
+
   // Complex configuration https://github.com/NatLibFi/marc-record-validators-melinda/issues/45
   describe('#validate: Complex configuration (spec)', () => {
     const config = [
@@ -517,14 +625,14 @@ describe('field-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: []});
+      const {valid, message} = await validator.validate(recordValid);
+      expect({valid, message}).to.eql({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: ['Field $500 should be excluded']});
+      const {valid, message} = await validator.validate(recordInvalid);
+      expect({valid, message}).to.eql({valid: false, message: ['Field $500 should be excluded']});
     });
 
     it('Repairs invalid record', async () => {
@@ -634,20 +742,20 @@ describe('field-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: []});
+      const {valid, message} = await validator.validate(recordValid);
+      expect({valid, message}).to.eql({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: ['Field $650 should be excluded']});
+      const {valid, message} = await validator.validate(recordInvalid);
+      expect({valid, message}).to.eql({valid: false, message: ['Field $650 should be excluded']});
     });
 
     it('Finds the record invalid (spec)', async () => {
       const validator = await validatorFactory(config);
-      const result = await validator.validate(recordInvalidMulti);
-      expect(result).to.eql({valid: false, message: [
+      const {valid, message} = await validator.validate(recordInvalidMulti);
+      expect({valid, message}).to.eql({valid: false, message: [
         'Field $648 should be excluded',
         'Field $650 should be excluded',
         'Field $650 should be excluded',
@@ -750,26 +858,26 @@ describe('field-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: []});
+      const {valid, message} = await validator.validate(recordValid);
+      expect({valid, message}).to.eql({valid: true, message: []});
     });
 
     it('Finds the record valid - Value', async () => {
       const validator = await validatorFactory(configValue);
-      const result = await validator.validate(recordValid);
-      expect(result).to.eql({valid: true, message: []});
+      const {valid, message} = await validator.validate(recordValid);
+      expect({valid, message}).to.eql({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: ['Field $500 should be excluded']});
+      const {valid, message} = await validator.validate(recordIndInvalid);
+      expect({valid, message}).to.eql({valid: false, message: ['Field $500 should be excluded']});
     });
 
     it('Finds the record invalid - Value', async () => {
       const validator = await validatorFactory(configValue);
-      const result = await validator.validate(recordValueInvalid);
-      expect(result).to.eql({valid: false, message: ['Field $500 should be excluded']});
+      const {valid, message} = await validator.validate(recordValueInvalid);
+      expect({valid, message}).to.eql({valid: false, message: ['Field $500 should be excluded']});
     });
 
     it('Repairs invalid record - Ind', async () => {
@@ -807,9 +915,9 @@ describe('field-exclusion', () => {
       });
 
       const validator = await validatorFactory(config);
-      const result = await validator.validate(record);
+      const {valid, message} = await validator.validate(record);
 
-      expect(result).to.eql({valid: false, message: ['Field $041 should be excluded']});
+      expect({valid, message}).to.eql({valid: false, message: ['Field $041 should be excluded']});
     });
   });
 });

package/src/fields-present.spec.js

@@ -79,6 +79,29 @@ describe('fields-present', () => {
 
       expect(result).to.eql({valid: true, messages: []});
     });
+    it('Finds the record valid', async () => {
+      const tagPatterns = [/^(020|022|024)$/u]; // eslint-disable-line
+      const validator = await validatorFactory(tagPatterns);
+      const record = new MarcRecord({
+        fields: [
+          {
+            tag: '020',
+            ind1: ' ',
+            ind2: '0',
+            subfields: [{code: 'a', value: 'foo'}]
+          },
+          {
+            tag: '040',
+            ind1: ' ',
+            ind2: '0',
+            subfields: [{code: 'a', value: 'foo'}]
+          }
+        ]
+      });
+      const result = await validator.validate(record);
+
+      expect(result).to.eql({valid: true, messages: []});
+    });
     it('Finds the record invalid', async () => {
       const tagPatterns = [/^5..$/u, /^FOO$/u];
       const validator = await validatorFactory(tagPatterns);
@@ -90,6 +113,12 @@ describe('fields-present', () => {
             ind2: '0',
             subfields: [{code: 'a', value: 'foo'}]
           },
+          {
+            tag: '500',
+            ind1: ' ',
+            ind2: '0',
+            subfields: [{code: 'a', value: 'foo'}]
+          },
           {
             tag: 'BAR',
             ind1: '1',
@@ -100,7 +129,7 @@ describe('fields-present', () => {
       });
       const result = await validator.validate(record);
 
-      expect(result).to.eql({valid: false, messages: ['The following tag patterns are not present in the record tag field:  /^5..$/u /^FOO$/u']});
+      expect(result).to.eql({valid: false, messages: ['The following tag patterns are not present in the record tag field:   /^FOO$/u']});
     });
   });
 });