@natlibfi/marc-record-merge 5.0.0 → 6.0.0-beta.10

package/package.json

@@ -1,59 +1,103 @@
 {
-  "name": "@natlibfi/marc-record-merge",
-  "description": "A configurable Javascript module for merging MARC records",
-  "author": {
-    "name": "The National Library of Finland"
-  },
-  "keywords": [
-    "marc",
-    "record",
-    "merge",
-    "merging",
-    "combine",
-    "combining",
-    "bibliography",
-    "bibliographic",
-    "catalog",
-    "library",
-    "libraries"
-  ],
-  "homepage": "https://github.com/NatLibFi/marc-record-merge",
-  "bugs": {
-    "url": "https://github.com/NatLibFi/marc-record-merge/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git@github.com:NatLibFi/marc-record-merge.git"
-  },
-  "license": "AGPL-3.0",
-  "version": "5.0.0",
-  "main": "./lib/main.js",
-  "scripts": {
-    "lint": "jshint .",
-    "test": "istanbul cover _mocha test/nodejs/*.spec.js",
-    "test:watch": "mocha test/nodejs/*.spec.js -w",
-    "test-browser": "npm run generate-requirejs-config && karma start",
-    "cover": "npm run test && istanbul check-coverage",
-    "check": "npm run lint && npm run cover",
-    "generate-requirejs-config": "requirejs-configurator --npm --include-dev-dependencies --exclude-peer-dependencies > test/browser/main.js",
-    "publish-to-npm": "npm install && npm run check && npm publish --access=public"
-  },
-  "dependencies": {
-    "marc-record-js": "^0.1.1",
-    "@natlibfi/es6-polyfills": "^2.0.0",
-    "@natlibfi/es6-shims": "^2.0.0"
-  },
-  "devDependencies": {
-    "chai": "^3.5.0",
-    "jshint": "^2.9.3",
-    "mocha": "^3.0.2",
-    "istanbul": "^0.4.5",
-    "karma": "^1.2.0",
-    "karma-mocha": "^1.1.1",
-    "karma-requirejs": "https://github.com/natlibfi-arlehiko/karma-requirejs#fix-npm3-dist",
-    "karma-requirejs-preprocessor": "^0.0.2",
-    "requirejs": "^2.3.2",
-    "requirejs-configurator": "https://github.com/natlibfi-arlehiko/requirejs-configurator#peer-deps",
-    "codeclimate-test-reporter": "^0.3.3"
-  }
+	"name": "@natlibfi/marc-record-merge",
+	"description": "Merge MARC records",
+	"author": {
+		"name": "The National Library of Finland"
+	},
+	"keywords": [],
+	"homepage": "https://github.com/natlibfi/marc-record-merge-js",
+	"bugs": {
+		"url": "https://github.com/natlibfi/marc-record-merge-js/issues"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git@github.com:natlibfi/marc-record-merge-js.git"
+	},
+	"license": "MIT",
+	"version": "6.0.0-beta.10",
+	"main": "./dist/index.js",
+	"engines": {
+		"node": ">=14"
+	},
+	"type": "commonjs",
+	"scripts": {
+		"prepare": "npm run build",
+		"prepublishOnly": "npm run build:transpile",
+		"lint": "eslint ./src",
+		"lint:dev": "eslint ./src --fix",
+		"test:base": "cross-env NODE_ENV=test mocha --require @babel/register --reporter-option maxDiffSize=15000 src/reducers/*.spec.js",
+		"test": "npm run lint && npm run test:base",
+		"test:dev": "npm run lint:dev && npm run coverage",
+		"coverage": "npm run coverage:unit && npm run coverage:report",
+		"coverage:unit": "nyc --silent npm run test:base",
+		"coverage:report": "nyc report",
+		"build:transpile": "babel src --copy-files --source-maps --delete-dir-on-start --out-dir=dist",
+		"build": "npm run build:transpile",
+		"dev:test": "cross-env NODE_ENV=test nodemon -w src -w test-fixtures --exec 'clear && npm run test:dev'",
+		"dev:test:debug": "cross-env DEBUG=@natlibfi/* NODE_ENV=test nodemon -w src -w test-fixtures --exec 'clear && npm run test:dev'"
+	},
+	"dependencies": {
+		"@natlibfi/fixugen": "1.1.0",
+		"@natlibfi/fixura": "^2.2.1",
+		"@natlibfi/marc-record": "^7.1.0-alpha.2",
+		"debug": "^4.3.4",
+		"normalize-diacritics": "2.14.0"
+	},
+	"devDependencies": {
+		"@babel/cli": "^7.17.10",
+		"@babel/core": "^7.18.5",
+		"@babel/eslint-parser": "^7.18.2",
+		"@babel/preset-env": "^7.18.2",
+		"@babel/register": "^7.17.7",
+		"@natlibfi/eslint-config-melinda-backend": "^2.0.0",
+		"babel-plugin-istanbul": "^6.1.1",
+		"babel-plugin-rewire": "^1.2.0",
+		"chai": "^4.3.6",
+		"cross-env": "^7.0.3",
+		"eslint": "^8.17.0",
+		"mocha": "^10.0.0",
+		"nodemon": "^2.0.16",
+		"nyc": "^15.1.0"
+	},
+	"eslintConfig": {
+		"extends": [
+			"@natlibfi/melinda-backend"
+		]
+	},
+	"babel": {
+		"presets": [
+			[
+				"@babel/preset-env",
+				{
+					"targets": "maintained node versions"
+				}
+			]
+		],
+		"env": {
+			"test": {
+				"plugins": [
+					"rewire",
+					"istanbul"
+				]
+			}
+		}
+	},
+	"nyc": {
+		"exclude": [
+			"*/*.spec.js",
+			"*/**/*.spec.js"
+		],
+		"reporter": [
+			"text"
+		],
+		"require": [
+			"@babel/register"
+		],
+		"sourceMap": false,
+		"instrument": false,
+		"lines": 80,
+		"statements": 80,
+		"functions": 80,
+		"branches": 80
+	}
 }

package/src/index.js

@@ -0,0 +1,34 @@
+import Reducers from './reducers';
+
+export {Reducers};
+// export default ({base, source, reducers}) => reducers.reduce((base, reducer) => reducer(base, source), base);
+
+// NV: Modified the reducer loop so, that not only base, but also is carried back.
+// However, we try to be backward-compatible: normally after the reducers, only base is returned.
+export default ({base, source, reducers}) => {
+  const combo = {base, source}; // eslint-disable-line functional/no-let
+
+  reducers.reduce((combo, reducer) => {
+    combo = singleRound(reducer, combo.base, combo.source); // eslint-disable-line no-param-reassign
+
+    return combo;
+  }, combo);
+
+  // Hack to make my melinda-marc-record-merge-reducers single tests that expect both
+  // base and source to return them both:
+  if (reducers.length === 1 && combo.base && combo.source) {
+    return combo;
+  }
+  // All other tests return just base... Backward (compability) it is!
+  return combo.base;
+
+  function singleRound(reducer, base, source) {
+    const combo = reducer(base, source);
+    if (combo.base !== undefined && combo.source !== undefined) {
+      //console.info('NEW STYLE REDUCER RESULT v2'); // eslint-disable-line no-console
+      return combo;
+    }
+    //console.info('OLD SCHOOL REDUCER RESULT v2'); // eslint-disable-line no-console
+    return {base: combo.base, source};
+  }
+};

package/src/reducers/copy.js

@@ -0,0 +1,251 @@
+/* eslint-disable max-statements */
+/* eslint-disable no-unused-vars */
+
+import {MarcRecord} from '@natlibfi/marc-record';
+import createDebugLogger from 'debug';
+
+export default ({
+  tagPattern,
+  compareTagsOnly = false,
+  compareWithoutTag = false,
+  compareWithoutIndicators = false,
+  compareWithoutIndicator1 = false,
+  compareWithoutIndicator2 = false,
+  subfieldsMustBeIdentical = true,
+  excludeSubfields = [],
+  dropSubfields = [],
+  copyUnless = [],
+  baseValidators = {subfieldValues: false},
+  sourceValidators = {subfieldValues: false},
+  swapTag = [],
+  swapSubfieldCode = [],
+  doNotCopyIfFieldPresent = false
+}) => (base, source) => {
+  const baseRecord = new MarcRecord(base, baseValidators);
+  const sourceRecord = new MarcRecord(source, sourceValidators);
+
+  const debug = createDebugLogger('@natlibfi/marc-record-merge');
+  const debugOptions = createDebugLogger('@natlibfi/marc-record-merge:compare-options');
+  const debugCompare = createDebugLogger('@natlibfi/marc-record-merge:compare');
+
+  const ignoreInd1 = compareWithoutIndicators || compareWithoutIndicator1;
+  const ignoreInd2 = compareWithoutIndicators || compareWithoutIndicator2;
+
+  debugOptions(`Tag Pattern: ${tagPattern}`);
+  debugOptions(`Compare tags only: ${compareTagsOnly}`);
+  debugOptions(`Omit indicator 1 from comparison: ${ignoreInd1}`);
+  debugOptions(`Omit indicator 2 from comparison: ${ignoreInd2}`);
+  debugOptions(`Copy if identical: ${subfieldsMustBeIdentical}`);
+  debugOptions(`Exclude subfields: [${excludeSubfields}]`);
+  debugOptions(`Drop subfields [${dropSubfields}]`);
+  debugOptions(`Copy unless contains subfields: ${JSON.stringify(copyUnless)}`);
+
+  const baseFields = baseRecord.get(tagPattern);
+  const sourceFields = sourceRecord.get(tagPattern);
+  const doNotCopy = doNotCopyIfFieldPresent ? baseRecord.get(doNotCopyIfFieldPresent).length > 0 : false;
+
+  if (doNotCopy) {
+    return baseRecord.toObject();
+  }
+  debug(`FFS: ${compareWithoutIndicator1}, ${compareWithoutIndicators}, ${ignoreInd1}`);
+  debug(`Base fields: `, baseFields);
+  debug(`Source fields: `, sourceFields);
+
+  // Logic steps
+  const baseCompareFields = baseFields.map(baseField => createCompareField(baseField));
+  const compareResultFields = compareFields(sourceFields, baseCompareFields);
+  const droppedUnwantedSubfield = checkDropSubfields(compareResultFields);
+  const droppedUnwantedFields = checkCopyUnlessFields(droppedUnwantedSubfield);
+  const swappedSubfields = checkSwapSubfieldCodes(droppedUnwantedFields);
+  const swappedTags = checkSwapTag(swappedSubfields);
+  const uniqueFields = [...new Set(swappedTags.map(field => JSON.stringify(field)))].map(field => JSON.parse(field));
+  debug('Fields to be copied');
+  debug(JSON.stringify(uniqueFields));
+
+  // Add fields to base;
+  uniqueFields.forEach(field => baseRecord.insertField(field));
+  return baseRecord.toObject();
+
+  function compareFields(sourceFields, baseCompareFields, uniqFields = []) {
+    const [sourceField, ...rest] = sourceFields;
+    if (sourceField === undefined) {
+      return uniqFields;
+    }
+
+    if (baseCompareFields.length === 0) {
+      return compareFields(rest, baseCompareFields, [...uniqFields, sourceField]);
+    }
+
+    // Source and base are also compared for identicalness
+    // Non-identical fields are copied from source to base as duplicates
+    const sourceCompareField = createCompareField(sourceField);
+    const unique = checkCompareFields(baseCompareFields, sourceCompareField);
+
+    debugCompare(`${JSON.stringify(sourceField)} ${unique ? 'is UNIQUE' : 'not UNIQUE'}`);
+
+    if (unique) {
+      return compareFields(rest, baseCompareFields, [...uniqFields, sourceField]);
+    }
+
+    return compareFields(rest, baseCompareFields, uniqFields);
+
+    function checkCompareFields(baseCompareFields, sourceCompareField) {
+      let unique = true; // eslint-disable-line functional/no-let
+
+      baseCompareFields.forEach(baseCompareField => {
+        debugCompare(`Comparing ${JSON.stringify(sourceCompareField)} to ${JSON.stringify(baseCompareField)}}`);
+
+        if (sourceCompareField.value !== baseCompareField.value) {
+          debugCompare(`Value is different ${sourceCompareField.value} !== ${baseCompareField.value}`);
+          return;
+        }
+
+        if (sourceCompareField.ind1 !== baseCompareField.ind1) {
+          debugCompare(`Ind1 is different ${sourceCompareField.ind1} !== ${baseCompareField.ind1}`);
+          return;
+        }
+
+        if (sourceCompareField.ind2 !== baseCompareField.ind2) {
+          debugCompare(`Ind2 is different ${sourceCompareField.ind2} !== ${baseCompareField.ind2}`);
+          return;
+        }
+
+        if ('subfields' in sourceCompareField) {
+          const allFound = checkSubfields(sourceCompareField.subfields, baseCompareField.subfields);
+          debugCompare(`Subfields are different ${!allFound}`);
+          if (!allFound) {
+            return;
+          }
+
+          unique = false;
+          return;
+        }
+
+        unique = false;
+        return;
+      });
+
+      return unique;
+    }
+
+    function checkSubfields(sourceSubfields, baseSubfields) {
+      const foundSubs = sourceSubfields.filter(sSub => baseSubfields.some(bSub => sSub.code === bSub.code && sSub.value === bSub.value));
+
+      if (subfieldsMustBeIdentical) {
+        return foundSubs.length === sourceSubfields.length && foundSubs.length === baseSubfields.length;
+      }
+
+      return foundSubs.length === sourceSubfields.length;
+    }
+  }
+
+  // compare objects have only fields that matter in comparison
+  function createCompareField(field) {
+    if (compareTagsOnly) {
+      return {tag: field.tag};
+    }
+
+    if ('value' in field) {
+      return {tag: field.tag, value: field.value};
+    }
+
+    const [filteredField] = checkDropSubfields([field]);
+    const [foundRule] = swapTag.filter(rule => new RegExp(rule.from, 'u').test(field.tag));
+    const replacementTag = foundRule ? foundRule.to : undefined;
+
+    const params = [
+      {name: 'tag', value: compareWithoutTag ? replacementTag : field.tag},
+      {name: 'ind1', value: ignoreInd1 ? undefined : field.ind1},
+      {name: 'ind2', value: ignoreInd2 ? undefined : field.ind2},
+      {name: 'subfields', value: createCompareSubfields(filteredField.subfields)}
+    ].map(param => [param.name, param.value]);
+
+    return Object.fromEntries(params);
+
+    function createCompareSubfields(subfields) {
+      const nonExcludedSubfields = subfields.filter(sub => !excludeSubfields.some(code => code === sub.code));
+      const normalizedSubfields = nonExcludedSubfields.map(sub => ({code: sub.code, value: normalizeSubfieldValue(sub.value)}));
+
+      return normalizedSubfields;
+
+      function normalizeSubfieldValue(value) {
+        return value.toLowerCase().replace(/\s+/ug, '');
+      }
+    }
+  }
+
+  function checkSwapTag(fields) {
+    if (swapTag.length > 0) {
+      return fields.map(field => ({...field, tag: swapTagsFunc(field.tag)}));
+    }
+
+    return fields;
+
+    function swapTagsFunc(tag) {
+      const [foundRule] = swapTag.filter(rule => new RegExp(rule.from, 'u').test(tag));
+
+      if (foundRule === undefined) {
+        return tag;
+      }
+
+      return foundRule.to;
+    }
+  }
+
+  function checkSwapSubfieldCodes(fields) {
+    if (swapSubfieldCode.length > 0) {
+      return fields.map(field => ({...field, subfields: swapSubfieldCodesFunc(field.subfields)}));
+    }
+
+    return fields;
+
+    function swapSubfieldCodesFunc(subfields) {
+      return subfields.map(sub => {
+        const [foundRule] = swapSubfieldCode.filter(rule => rule.from === sub.code);
+
+        if (foundRule === undefined) {
+          return sub;
+        }
+
+        return {code: foundRule.to, value: sub.value};
+      });
+    }
+  }
+
+  function checkDropSubfields(fields) {
+    if (dropSubfields.length > 0) {
+      return fields.map(field => ({...field, subfields: dropSubfieldsFunc(field.subfields)}))
+        .filter(field => field.subfields.length > 0);
+    }
+
+    return fields;
+
+    function dropSubfieldsFunc(subfields) {
+      return subfields.filter(sub => { // eslint-disable-line
+        return !dropSubfields.some(({code, value = false, condition = false}) => {
+          if (code !== sub.code) {
+            return false;
+          }
+
+          if (!condition && value) {
+            return value === sub.value;
+          }
+
+          if (condition === 'unless' && value) {
+            return !new RegExp(value, 'u').test(sub.value);
+          }
+
+          return true;
+        });
+      });
+    }
+  }
+
+  function checkCopyUnlessFields(fields) {
+    if (copyUnless.length > 0) {
+      return fields.filter(({subfields}) => copyUnless.some(filter => !subfields.some(sub => sub.code === filter.code && new RegExp(filter.value, 'u').test(sub.value))));
+    }
+
+    return fields;
+  }
+};

package/src/reducers/copy.spec.js

@@ -0,0 +1,54 @@
+import {expect} from 'chai';
+import {READERS} from '@natlibfi/fixura';
+import createReducer from './copy';
+import generateTests from '@natlibfi/fixugen';
+
+//import createDebugLogger from 'debug'; // <---
+//const debug = createDebugLogger('@natlibfi/marc-record-merge/copy.spec.js'); // <---
+
+generateTests({
+  callback,
+  path: [__dirname, '..', '..', 'test-fixtures', 'reducers', 'copy'],
+  useMetadataFile: true,
+  recurse: true,
+  fixura: {
+    reader: READERS.JSON,
+    failWhenNotFound: false
+  }
+});
+
+function callback({
+  getFixture,
+  tagPatternRegExp,
+  compareTagsOnly = false,
+  compareWithoutTag = false,
+  compareWithoutIndicators = false,
+  compareWithoutIndicator1 = false,
+  compareWithoutIndicator2 = false,
+  subfieldsMustBeIdentical = false,
+  copyUnless = undefined,
+  excludeSubfields = undefined,
+  dropSubfields = undefined,
+  swapSubfieldCode = [],
+  swapTag = [],
+  doNotCopyIfFieldPresent = false
+}) {
+  const base = getFixture('base.json');
+  const source = getFixture('source.json');
+  const tagPattern = new RegExp(tagPatternRegExp, 'u');
+  const expectedRecord = getFixture('merged.json');
+
+  const merged = createReducer({
+    tagPattern, compareTagsOnly, compareWithoutTag, compareWithoutIndicators, compareWithoutIndicator1, compareWithoutIndicator2,
+    copyUnless, subfieldsMustBeIdentical, excludeSubfields,
+    dropSubfields, swapSubfieldCode, swapTag,
+    doNotCopyIfFieldPresent
+  })(base, source);
+  //debug(`***     mergedRecord: `, mergedRecord); //<--
+  //debug(`***     mergedRecord,Strfy: `, JSON.stringify(mergedRecord)); //<--
+  //debug(`***     expectedRecord: `, expectedRecord); //<--
+  //debug(`***     expectedRecord,Strfy: `, JSON.stringify(expectedRecord)); //<--
+  expect(merged.constructor.name).not.to.eql('MarcRecord');
+  expect(merged.constructor.name).to.eql('Object');
+  expect(merged).to.eql(expectedRecord);
+}

package/src/reducers/index.js

@@ -0,0 +1,4 @@
+import copy from './copy';
+import select, {strictEquality, subsetEquality} from './select';
+
+export default {copy, select, strictEquality, subsetEquality};

package/src/reducers/select.js

@@ -0,0 +1,110 @@
+import {normalizeSync} from 'normalize-diacritics';
+import createDebugLogger from 'debug';
+import {MarcRecord} from '@natlibfi/marc-record';
+
+export function strictEquality(subfieldA, subfieldB) {
+  return subfieldA.code === subfieldB.code &&
+    subfieldA.value === subfieldB.value;
+}
+
+export function subsetEquality(subfieldA, subfieldB) {
+  return subfieldA.code === subfieldB.code &&
+    (subfieldA.value.indexOf(subfieldB.value) !== -1 || subfieldB.value.indexOf(subfieldA.value) !== -1);
+}
+// EqualityFunction can be either strictEquality or subsetEquality
+export default ({tagPattern, equalityFunction = strictEquality}) => (base, source) => {
+  const debug = createDebugLogger('@natlibfi/marc-record-merge:select');
+  const baseRecord = new MarcRecord(base, {subfieldValues: false});
+  const sourceRecord = new MarcRecord(source, {subfieldValues: false});
+  const baseFields = baseRecord.get(tagPattern);
+  const sourceFields = sourceRecord.get(tagPattern);
+  const fieldTag = sourceFields.map(field => field.tag);
+  debug(`Comparing field ${fieldTag}`);
+
+  checkFieldType(baseFields);
+  checkFieldType(sourceFields);
+
+  if (baseFields.length > 1 || sourceFields.length > 1) {
+    debug(`Multiple fields in base or source`);
+    debug(`No changes to base`);
+    return base;
+  }
+  const [baseField] = baseFields;
+  const [sourceField] = sourceFields;
+
+  if (baseField.tag === sourceField.tag === false) {
+    debug(`Base tag ${baseField.tag} is not equal to source tag ${sourceField.tag}`);
+    debug(`No changes to base`);
+    return base;
+  }
+  const baseSubs = baseField.subfields;
+  const sourceSubs = sourceField.subfields;
+
+  const baseSubsNormalized = baseSubs
+    .map(({code, value}) => ({code, value: normalizeSubfieldValue(value)}));
+
+  const sourceSubsNormalized = sourceSubs
+    .map(({code, value}) => ({code, value: normalizeSubfieldValue(value)}));
+
+  // Returns the base subfields for which a matching source subfield is found
+  const equalSubfieldsBase = baseSubsNormalized
+    .filter(baseSubfield => sourceSubsNormalized
+      .some(sourceSubfield => equalityFunction(baseSubfield, sourceSubfield)));
+  debug(`equalSubfieldsBase: ${JSON.stringify(equalSubfieldsBase, undefined, 2)}`);
+
+  // Returns the source subfields for which a matching base subfield is found
+  const equalSubfieldsSource = sourceSubsNormalized
+    .filter(sourceSubfield => baseSubsNormalized
+      .some(baseSubfield => equalityFunction(sourceSubfield, baseSubfield)));
+  debug(`equalSubfieldsSource: ${JSON.stringify(equalSubfieldsSource, undefined, 2)}`);
+
+  if (baseSubs.length === sourceSubs.length && equalSubfieldsBase.length < baseSubs.length) {
+    debug(`Base and source subfields are not equal`);
+    debug(`No changes to base`);
+    return base;
+  }
+
+  if (baseSubs.length === sourceSubs.length && equalSubfieldsBase.length === equalSubfieldsSource.length) {
+    debug(`Checking subfield equality`);
+    const totalSubfieldLengthBase = baseSubsNormalized
+      .map(({value}) => value.length)
+      .reduce((acc, value) => acc + value);
+    const totalSubfieldLengthSource = sourceSubsNormalized
+      .map(({value}) => value.length)
+      .reduce((acc, value) => acc + value);
+
+    if (totalSubfieldLengthSource > totalSubfieldLengthBase) {
+      return replaceBasefieldWithSourcefield(base);
+    }
+  }
+
+  if (sourceSubs.length > baseSubs.length && equalSubfieldsBase.length === baseSubs.length) {
+    return replaceBasefieldWithSourcefield(base);
+  }
+
+  debug(`No changes to base`);
+  return base;
+
+  function replaceBasefieldWithSourcefield(base) {
+    const index = base.fields.findIndex(field => field === baseField);
+    base.fields.splice(index, 1, sourceField); // eslint-disable-line functional/immutable-data
+    debug(`Source field is longer, replacing base with source`);
+    return base;
+  }
+
+  function checkFieldType(fields) {
+    const checkedFields = fields.map(field => {
+      if ('value' in field) { // eslint-disable-line functional/no-conditional-statement
+        throw new Error('Invalid control field, expected data field');
+      }
+      return field;
+    });
+    return checkedFields;
+  }
+
+  function normalizeSubfieldValue(value) {
+    // Regexp options: g: global search, u: unicode
+    const punctuation = /[.,\-/#!?$%^&*;:{}=_`~()[\]]/gu;
+    return normalizeSync(value).toLowerCase().replace(punctuation, '', 'u').replace(/\s+/gu, ' ').trim();
+  }
+};

package/src/reducers/select.spec.js

@@ -0,0 +1,49 @@
+import {expect} from 'chai';
+import {MarcRecord} from '@natlibfi/marc-record';
+import createReducer, {subsetEquality} from './select';
+import {READERS} from '@natlibfi/fixura';
+import generateTests from '@natlibfi/fixugen';
+
+MarcRecord.setValidationOptions({subfieldValues: false});
+
+generateTests({
+  callback,
+  path: [__dirname, '..', '..', 'test-fixtures', 'reducers', 'select'],
+  useMetadataFile: true,
+  recurse: false,
+  fixura: {
+    reader: READERS.JSON,
+    failWhenNotFound: false
+  }
+});
+
+function callback({
+  getFixture,
+  disabled = false,
+  tagPatternRegExp = false,
+  expectedError = false,
+  useSubsetEquality = false
+}) {
+  if (disabled) {
+    console.log('TEST DISABLED!'); // eslint-disable-line no-console
+    return;
+  }
+  //  const base = new MarcRecord(getFixture('base.json'), {subfieldValues: false});
+  //  const source = new MarcRecord(getFixture('source.json'), {subfieldValues: false});
+
+  const base = getFixture('base.json');
+  const source = getFixture('source.json');
+
+  const tagPattern = new RegExp(tagPatternRegExp, 'u');
+  const expectedRecord = getFixture('merged.json');
+  const equalityFunction = useSubsetEquality ? subsetEquality : undefined;
+
+  // Bypass expected error in testing
+  if (expectedError) {
+    expect(() => createReducer.to.throw(Error, 'control field'));
+    return;
+  }
+
+  const mergedRecord = createReducer({tagPattern, equalityFunction})(base, source);
+  expect(mergedRecord).to.eql(expectedRecord);
+}

package/test-fixtures/reducers/copy/01 - copy/01/base.json

@@ -0,0 +1,9 @@
+{
+    "leader": "01331cam a22003494i 4500",
+    "fields": [
+        {
+            "tag": "001",
+            "value": "007346734"
+        }
+    ]
+}