@natlibfi/marc-record-validators-melinda 3.2.0 → 3.3.14-alpha.2

package/src/duplicates-ind1.spec.js

@@ -1,126 +1,48 @@
-/**
- *
- * @licstart  The following is the entire license notice for the JavaScript code in this file.
- *
- * MARC record validators used in Melinda
- *
- * Copyright (C) 2014-2018 University Of Helsinki (The National Library Of Finland)
- *
- * This file is part of marc-record-validators-melinda
- *
- * marc-record-validators-melinda program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as
- * published by the Free Software Foundation, either version 3 of the
- * License, or (at your option) any later version.
- *
- * marc-record-validators-melinda is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * @licend  The above is the entire license notice
- * for the JavaScript code in this file.
- *
- */
-
-/* eslint-disable no-undef, max-nested-callbacks, no-unused-expressions */
-
-'use strict';
-
 import {expect} from 'chai';
 import {MarcRecord} from '@natlibfi/marc-record';
-import validatorFactory from '../src/duplicates-ind1';
+import validatorFactory from './duplicates-ind1';
+
+import {READERS} from '@natlibfi/fixura';
+import generateTests from '@natlibfi/fixugen';
+import createDebugLogger from 'debug';
+
+generateTests({
+  callback,
+  path: [__dirname, '..', 'test-fixtures', 'duplicates-ind1'],
+  useMetadataFile: true,
+  recurse: false,
+  fixura: {
+    reader: READERS.JSON
+  },
+  mocha: {
+    before: () => testValidatorFactory()
+  }
+});
 
-describe('duplicates-ind1', () => {
-	it('Creates a validator', async () => {
-		const validator = await validatorFactory(/^245$/);
+const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/duplicates-ind1:test');
 
-		expect(validator)
-			.to.be.an('object')
-			.that.has.any.keys('description', 'validate');
+async function testValidatorFactory() {
+  const validator = await validatorFactory(/^500$/u);
 
-		expect(validator.description).to.be.a('string');
-		expect(validator.validate).to.be.a('function');
-	});
+  expect(validator)
+    .to.be.an('object')
+    .that.has.any.keys('description', 'validate');
 
-	describe('#validate', () => {
-		it('Finds the record valid', async () => {
-			const validator = await validatorFactory(/^500$/);
-			const record = new MarcRecord({
-				fields: [
-					{
-						tag: '500',
-						ind1: ' ',
-						ind2: '0',
-						subfields: [{code: 'a', value: 'foo'}]
-					},
-					{
-						tag: '500',
-						ind1: ' ',
-						ind2: '0',
-						subfields: [{code: 'a', value: 'foo'}]
-					}
-				]
-			});
-			const result = await validator.validate(record);
+  expect(validator.description).to.be.a('string');
+  expect(validator.validate).to.be.a('function');
+}
 
-			expect(result).to.eql({valid: true, messages: []});
-		});
-		it('Finds the record invalid', async () => {
-			const validator = await validatorFactory(/^500$/);
-			const record = new MarcRecord({
-				fields: [
-					{
-						tag: '500',
-						ind1: ' ',
-						ind2: '0',
-						subfields: [{code: 'a', value: 'foo'}]
-					},
-					{
-						tag: '500',
-						ind1: '1',
-						ind2: '0',
-						subfields: [{code: 'a', value: 'foo'}]
-					}
-				]
-			});
-			const result = await validator.validate(record);
+async function callback({getFixture, tagPattern, fix = false}) {
+  const validator = await validatorFactory(new RegExp(tagPattern, 'u'));
+  const record = new MarcRecord(getFixture('record.json'));
+  const expectedResult = getFixture('expectedResult.json');
 
-			expect(result).to.eql({valid: false, messages: ['Multiple 500 fields which only differ in the first indicator']});
-		});
-	});
+  if (!fix) {
+    const result = await validator.validate(record);
+    return expect(result).to.eql(expectedResult);
+  }
 
-	describe('#fix', () => {
-		it('Removes duplicate values', async () => {
-			const validator = await validatorFactory(/^500$/);
-			const record = new MarcRecord({
-				fields: [
-					{
-						tag: '500',
-						ind1: ' ',
-						ind2: '0',
-						subfields: [{code: 'a', value: 'foo'}]
-					},
-					{
-						tag: '500',
-						ind1: '1',
-						ind2: '0',
-						subfields: [{code: 'a', value: 'foo'}]
-					}
-				]
-			});
-			await validator.fix(record);
-			expect(record.fields).to.eql([
-				{
-					tag: '500',
-					ind1: ' ',
-					ind2: '0',
-					subfields: [{code: 'a', value: 'foo'}]
-				}
-			]);
-		});
-	});
-});
+  const fixedRecord = await validator.fix(record);
+  debug(fixedRecord);
+  expect(record.fields).to.eql(expectedResult);
+}

package/src/empty-fields.js

@@ -1,83 +1,71 @@
-/**
- *
- * @licstart  The following is the entire license notice for the JavaScript code in this file.
- *
- * MARC record validators used in Melinda
- *
- * Copyright (C) 2014-2018 University Of Helsinki (The National Library Of Finland)
- *
- * This file is part of marc-record-validators-melinda
- *
- * marc-record-validators-melinda program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as
- * published by the Free Software Foundation, either version 3 of the
- * License, or (at your option) any later version.
- *
- * marc-record-validators-melinda is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * @licend  The above is the entire license notice
- * for the JavaScript code in this file.
- *
- */
+const ERRORS = {
+  EMPTY_SUBFIELDS: 2,
+  MISSING_SUBFIELD_VALUES: 3
+};
 
-/**
-* DEPRECATED: This validator is not needed because @natlibfi/marc-record doesn't allow fields with empty values
-*/
+export default function () {
+  return {
+    description: 'Handles empty fields',
+    validate,
+    fix
+  };
 
-/* eslint-disable require-await */
-import {find, isEmpty, omit} from 'lodash';
+  function validate(record) {
+    const errors = findErrors(record.fields);
+    if (errors.length > 0) {
+      return {
+        valid: false,
+        messages: errors.map(error => { // eslint-disable-line array-callback-return
+          switch (error.code) {
+          case ERRORS.EMPTY_SUBFIELDS:
+            return `Field ${error.field.tag} has no subfields`;
+          case ERRORS.MISSING_SUBFIELD_VALUES:
+            return `Field ${error.field.tag} has missing subfield values: ${error.emptySubfields.map(sf => sf.code).join()}`;
+          default:
+          }
+        })
+      };
+    }
 
-export default async function () {
-	return {
-		description: 'Handles empty fields',
-		validate,
-		fix
-	};
+    return {valid: true};
+  }
 
-	async function validate(record) {
-		const result = searchFields(record);
-		const isValid = result.find(obj => obj.valid === false);
-		return isValid === undefined ? {valid: true, messages: []} : omit(isValid, ['field']);
-	}
+  function fix(record) {
+    const errors = findErrors(record.fields);
+    errors.forEach(error => {
+      if (error.code === ERRORS.MISSING_SUBFIELD_VALUES) { // eslint-disable-line functional/no-conditional-statements
+        if (error.emptySubfields.length === error.field.subfields.length) { // eslint-disable-line functional/no-conditional-statements
+          record.removeField(error.field);
+        } else { // eslint-disable-line functional/no-conditional-statements
+          error.emptySubfields.forEach(sf => {
+            record.removeSubfield(sf, error.field);
+          });
+        }
+      } else { // eslint-disable-line functional/no-conditional-statements
+        record.removeField(error.field);
+      }
+    });
+  }
 
-	async function fix(record) {
-		const fixFields = searchFields(record);
-		const isValid = fixFields.find(obj => obj.valid === false);
+  function findErrors(fields) {
+    return fields.reduce((errors, field) => {
+      if (field.subfields) {
+        if (field.subfields.length === 0) {
+          return errors.concat({field, code: ERRORS.EMPTY_SUBFIELDS});
+        }
 
-		if ('subfields' in isValid.field && !isEmpty(isValid.field.subfields)) {
-			record.removeSubfield(find(isValid.field.subfields, {value: ''}), isValid.field);
-		} else {
-			record.removeField(isValid);
-		}
-	}
-	function searchFields(record) {
-		let validationResult;
-		record.fields.forEach(obj => {
-			validationResult = [emptyControlFields(obj), emptySubfieldValues(obj), emptySubfields(obj)];
-		});
-		return validationResult;
-	}
+        const subfieldsWithoutValue = field.subfields.filter(sf => !sf.value);
 
-	function emptyControlFields(field) {
-		const result = 'value' in field && field.value.length === 0;
-		return result === false ? {valid: true} : {valid: false, messages: [`Field ${field.tag} has empty value`], field};
-	}
+        if (subfieldsWithoutValue.length > 0) {
+          return errors.concat({
+            field,
+            emptySubfields: subfieldsWithoutValue,
+            code: ERRORS.MISSING_SUBFIELD_VALUES
+          });
+        }
+      }
 
-	function emptySubfields(field) {
-		const result = field.subfields && field.subfields.length === 0;
-		return result === false ? {valid: true} : {valid: false, messages: [`Field ${field.tag} has no subfields`], field};
-	}
-
-	function emptySubfieldValues(field) {
-		if (field.subfields) {
-			const result = field.subfields.filter(subfield => subfield.value.length === 0);
-			return result.length === 0 ? {valid: true} : {valid: false, messages: result.map(item => `Field ${field.tag}$${item.code} has empty value`), field};
-		}
-	}
+      return errors;
+    }, []);
+  }
 }

package/src/empty-fields.spec.js

@@ -1,214 +1,141 @@
-/**
- *
- * @licstart  The following is the entire license notice for the JavaScript code in this file.
- *
- * MARC record validators used in Melinda
- *
- * Copyright (C) 2014-2018 University Of Helsinki (The National Library Of Finland)
- *
- * This file is part of marc-record-validators-melinda
- *
- * marc-record-validators-melinda program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as
- * published by the Free Software Foundation, either version 3 of the
- * License, or (at your option) any later version.
- *
- * marc-record-validators-melinda is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * @licend  The above is the entire license notice
- * for the JavaScript code in this file.
- *
- */
-
-/* eslint-disable no-undef, max-nested-callbacks, no-unused-expressions */
-
-'use strict';
 import {expect} from 'chai';
 import {MarcRecord} from '@natlibfi/marc-record';
 import validatorFactory from '../src/empty-fields';
 
-describe.skip('empty-fields **DEPRECATED**', () => {
-	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');
-	});
-
-	describe('#validate', () => {
-		it('Finds the record valid', async () => {
-			const validator = await validatorFactory();
-			const record = new MarcRecord({
-				fields: [
-					{
-						tag: '001',
-						value: '1234567',
-						subfields: [
-							{
-								code: 'a',
-								value: 'foo'
-							}
-						]
-					}
-				]
-			});
-			const result = await validator.validate(record);
-			expect(result).to.eql({valid: true, messages: []});
-		});
-
-		it('Finds an empty tag value', async () => {
-			const validator = await validatorFactory();
-			const record = new MarcRecord({
-				fields: [
-					{
-						tag: '008',
-						value: '',
-						subfields: [
-							{
-								code: 'a',
-								value: 'foo'
-							}
-						]
-					}
-				]
-			});
-			const result = await validator.validate(record);
-
-			expect(result).to.eql({valid: false, messages: ['Field 008 has empty value']});
-		});
-
-		it('Finds an empty subfield value', async () => {
-			const validator = await validatorFactory();
-			const record = new MarcRecord({
-				fields: [
-					{
-						tag: '245',
-						subfields: [
-							{
-								code: 'a',
-								value: ''
-							}
-						]
-					}
-				]
-			});
-			const result = await validator.validate(record);
-
-			expect(result).to.eql({valid: false, messages: ['Field 245$a has empty value']});
-		});
-
-		it('Finds an empty subfield array', async () => {
-			const validator = await validatorFactory();
-			const record = new MarcRecord({
-				fields: [
-					{
-						tag: '500',
-						subfields: [
-						]
-					}
-				]
-			});
-			const result = await validator.validate(record);
-
-			expect(result).to.eql({valid: false, messages: ['Field 500 has no subfields']});
-		});
-	});
-
-	describe('#fix', () => {
-		it('Removes tag with empty value', async () => {
-			const validator = await validatorFactory();
-			const record = new MarcRecord({
-				fields: [
-					{
-						tag: '001',
-						value: '1234567'
-					},
-					{
-						tag: '008',
-						value: ''
-					}
-				]
-			});
-			await validator.fix(record);
-
-			expect(record.fields).to.eql([
-				{
-					tag: '001',
-					value: '1234567'
-				}
-			]);
-		});
-
-		it('Removes an empty value inside subfields array', async () => {
-			const validator = await validatorFactory();
-			const record = new MarcRecord({
-				fields: [
-					{
-						tag: '245',
-						subfields: [
-							{
-								code: 'a',
-								value: 'foo'
-							},
-							{
-								code: 'b',
-								value: ''
-							}
-						]
-					}
-				]
-			});
-			await validator.fix(record);
-
-			expect(record.fields).to.eql(
-				[
-					{
-						tag: '245',
-						ind1: ' ',
-						ind2: ' ',
-						subfields: [
-							{
-								code: 'a',
-								value: 'foo'
-							}
-						]
-					}
-				]);
-		});
+before(() => {
+  MarcRecord.setValidationOptions({subfields: false, subfieldValues: false});
+});
 
-		it('Removes an empty subfields array', async () => {
-			const validator = await validatorFactory();
-			const record = new MarcRecord({
-				fields: [
-					{
-						tag: '001',
-						value: '1234567'
-					},
-					{
-						tag: '500',
-						subfields: [
-						]
-					}
-				]
-			});
-			await validator.fix(record);
+after(() => {
+  MarcRecord.setValidationOptions({});
+});
 
-			expect(record.fields).to.eql([
-				{
-					tag: '001',
-					value: '1234567'
-				}
-			]);
-		});
-	});
+describe('empty-fields', () => {
+  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');
+  });
+
+  describe('#validate', () => {
+    it('Finds the record valid', async () => {
+      const validator = await validatorFactory();
+      const record = new MarcRecord({
+        fields: [
+          {
+            tag: '001',
+            value: '1234567',
+            subfields: [
+              {
+                code: 'a',
+                value: 'foo'
+              }
+            ]
+          }
+        ]
+      });
+      const result = await validator.validate(record);
+      expect(result).to.to.have.property('valid', true);
+    });
+
+    it('Finds a missing subfield value', async () => {
+      const validator = await validatorFactory();
+      const record = new MarcRecord({
+        fields: [
+          {
+            tag: '245',
+            subfields: [
+              {
+                code: 'a'
+              }
+            ]
+          }
+        ]
+      });
+      const result = await validator.validate(record);
+
+      expect(result).to.eql({valid: false, messages: ['Field 245 has missing subfield values: a']});
+    });
+
+    it('Finds an empty subfield array', async () => {
+      const validator = await validatorFactory();
+      const record = new MarcRecord({
+        fields: [
+          {
+            tag: '500',
+            subfields: []
+          }
+        ]
+      });
+      const result = await validator.validate(record);
+
+      expect(result).to.eql({valid: false, messages: ['Field 500 has no subfields']});
+    });
+  });
+
+  describe('#fix', () => {
+    it('Removes a subfield with missing value', async () => {
+      const validator = await validatorFactory();
+      const record = new MarcRecord({
+        fields: [
+          {
+            tag: '245',
+            subfields: [
+              {
+                code: 'a',
+                value: 'foo'
+              },
+              {
+                code: 'b'
+              }
+            ]
+          }
+        ]
+      });
+      await validator.fix(record);
+
+      expect(record.fields).to.eql([
+        {
+          tag: '245',
+          ind1: ' ',
+          ind2: ' ',
+          subfields: [
+            {
+              code: 'a',
+              value: 'foo'
+            }
+          ]
+        }
+      ]);
+    });
+
+    it('Removes a field with no subfields', async () => {
+      const validator = await validatorFactory();
+      const record = new MarcRecord({
+        fields: [
+          {
+            tag: '001',
+            value: '1234567'
+          },
+          {
+            tag: '500',
+            subfields: []
+          }
+        ]
+      });
+      await validator.fix(record);
+
+      expect(record.fields).to.eql([
+        {
+          tag: '001',
+          value: '1234567'
+        }
+      ]);
+    });
+  });
 });