@natlibfi/marc-record-validators-melinda 10.13.1-alpha.2 → 10.14.0-alpha.1

package/src/sortFields.js

@@ -0,0 +1,393 @@
+// Taken from project marc-record-js, file marcSortFields.js as this contains more and more Melinda-specific rules.
+
+import clone from 'clone';
+import createDebugLogger from 'debug';
+import {fieldHasSubfield, fieldToString} from './utils';
+import {isValidSubfield8} from './subfield8Utils';
+import {isValidSubfield6, subfield6GetOccurrenceNumber} from './subfield6Utils';
+
+
+const BIG_BAD_NUMBER = 999.99;
+
+const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:sortFields');
+//const debugData = debug.extend('data');
+const debugDev = debug.extend('dev');
+
+export default function () {
+
+  return {
+    description: 'Sort fields',
+    validate, fix
+  };
+
+  function fix(record) {
+    const res = {message: [], fix: [], valid: true};
+
+    record.fields.sort(fieldOrderComparator); // eslint-disable-line functional/immutable-data
+
+    return res;
+  }
+
+  function validate(record) {
+    const res = {message: []};
+
+    const fields = record.fields.map(f => clone(f));
+    fields.sort(fieldOrderComparator); // eslint-disable-line functional/immutable-data
+
+
+    const relocatedFields = fields.filter((f, i) => fieldToString(f) !== fieldToString(record.fields[i]));
+
+    if (relocatedFields.length > 0) { // eslint-disable-line functional/no-conditional-statements
+      res.message.push(`${relocatedFields.length} field(s) in new places`); // eslint-disable-line functional/immutable-data
+    }
+
+    res.valid = !(res.message.length >= 1); // eslint-disable-line functional/immutable-data
+    return res;
+  }
+}
+
+
+export const relatorTermScore = { // Here bigger is better
+  // NB! This is exportable as field internal $e sorting in marc-record-validators-js uses this.
+  // NB! The more abstract, the earlier it appears.
+  // Note that terms with same abstraction level might also have order preferences
+  // We should 1) check the order of these, and 2) add translations (support Swedish at the very least)
+  // work/teos > expression/ekspressio > manifestation/manifestaatio
+  'säveltäjä': 100, 'composer': 100,
+  'kirjoittaja': 99, 'author': 100,
+  'sarjakuvantekijä': 99,
+  'taiteilija': 98,
+  'sanoittaja': 90,
+  'käsikirjoittaja': 90,
+  // expression:
+  'toimittaja': 80, 'editor': 80,
+  'sovittaja': 80, 'arranger': 80,
+  'kuvittaja': 75,
+  'editointi': 71, // for music, editor/toimittaja is another thing
+  'kääntäjä': 70,
+  'lukija': 61,
+  // Manifestation level
+  'esittäjä': 60,
+  'johtaja': 50, // orkesterinjohtaja
+  'kustantaja': 41,
+  'julkaisija': 40
+
+};
+
+export function scoreRelatorTerm(value) { // sortRelatorTerms.js validator should call this on future version
+  const normValue = value.replace(/[.,]+$/u, '');
+  if (normValue in relatorTermScore) {
+    return relatorTermScore[normValue];
+  }
+  return 0;
+}
+
+export function fieldOrderComparator(fieldA, fieldB) {
+
+  const sorterFunctions = [sortByTag, sortByIndexTerms, sortAlphabetically, sortByRelatorTerm, sortByOccurrenceNumber, preferFenniKeep, sortByFieldLinkAndSequenceNumber];
+
+  for (const sortFn of sorterFunctions) { // eslint-disable-line functional/no-loop-statements
+    const result = sortFn(fieldA, fieldB);
+    debugDev(`${sortFn.name}: '${fieldToString(fieldA)}' vs '${fieldToString(fieldB)}': ${result}`);
+    if (result !== 0) {
+      return result;
+    }
+  }
+
+  return 0;
+
+  function sortByTag(fieldA, fieldB) {
+
+    function getSortIndex(tag) {
+      const sortIndex = {
+        LDR: '000',
+        STA: '001.1', // STA comes now after 001. However 003+001 form a combo, so I'm not sure...
+        SID: '999.1',
+        LOW: '999.2',
+        CAT: '999.3',
+        HLI: '999.4'
+      };
+
+      if (tag in sortIndex) { // <- this allows weights for numeric values as well (not that we use them yet)
+        return sortIndex[tag];
+      }
+      if (isNaN(tag)) {
+        return '999.9';
+      }
+      return tag;
+    }
+
+    const orderA = getSortIndex(fieldA.tag);
+    const orderB = getSortIndex(fieldB.tag);
+
+    if (orderA > orderB) {
+      return 1;
+    }
+    if (orderA < orderB) {
+      return -1;
+    }
+
+    return 0;
+  }
+
+  function sortByIndexTerms(fieldA, fieldB) { // eslint-disable-line complexity, max-statements
+
+    const indexTermFields = ['600', '610', '611', '630', '648', '650', '651', '652', '653', '654', '655', '656', '657', '658', '659', '662'];
+
+    function scoreInd2(val) {
+      const ind2Score = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 8, '5': 5, '6': 6, '7': 7};
+
+      if (val in ind2Score) {
+        return ind2Score[val];
+      }
+      return 9;
+    }
+
+    // ATM this is not needed.
+    // You may need this, if you change compare function order in sorterFunctions
+    // istanbul ignore next
+    if (fieldA.tag !== fieldB.tag) {
+      return 0;
+    }
+
+    if (!indexTermFields.includes(fieldA.tag)) {
+      return 0;
+    }
+
+    /* Puts ind2=4 last */
+    if (scoreInd2(fieldA.ind2) > scoreInd2(fieldB.ind2)) {
+      return 1;
+    }
+    if (scoreInd2(fieldA.ind2) < scoreInd2(fieldB.ind2)) {
+      return -1;
+    }
+
+    function scoreDictionary(dictionary) {
+      const dictionarySortIndex = {
+        'yso/fin': 0,
+        'yso/swe': 1,
+        'yso/eng': 2,
+        'slm/fin': 0.1,
+        'slm/swe': 1.1,
+        'kauno/fin': 2.1,
+        'kauno/swe': 2.2,
+        'kaunokki': 4,
+        'bella': 5
+      };
+
+      if (dictionary in dictionarySortIndex) {
+        return dictionarySortIndex[dictionary];
+      }
+      return BIG_BAD_NUMBER;
+    }
+
+    const dictionaryA = selectFirstValue(fieldA, '2');
+    const dictionaryB = selectFirstValue(fieldB, '2');
+
+    const dictScoreA = scoreDictionary(dictionaryA);
+    const dictScoreB = scoreDictionary(dictionaryB);
+    // Use priority order for listed dictionaries:
+    if (dictScoreA > dictScoreB) {
+      return 1;
+    }
+    if (dictScoreA < dictScoreB) {
+      return -1;
+    }
+    // Unlisted dictionaries: sort $2 value alphabetically:
+    //if (dictScoreA === BIG_BAD_NUMBER) {
+    if (dictionaryA > dictionaryB) {
+      return 1;
+    }
+    if (dictionaryA < dictionaryB) {
+      return -1;
+    }
+    //}
+    return 0;
+  }
+
+  function preferKeep(fieldA, fieldB, keepOwner = 'FENNI') {
+    const hasKeepA = fieldHasSubfield(fieldA, '9', `${keepOwner}<KEEP>`);
+    const hasKeepB = fieldHasSubfield(fieldB, '9', `${keepOwner}<KEEP>`);
+
+    if (hasKeepA && !hasKeepB) {
+      return -1;
+    }
+    if (!hasKeepA && hasKeepB) {
+      return 1;
+    }
+
+    return 0;
+  }
+
+  function preferFenniKeep(fieldA, fieldB) {
+    const fenniPreference = preferKeep(fieldA, fieldB, 'FENNI');
+    if (fenniPreference !== 0) {
+      return fenniPreference;
+    }
+    const violaPreference = preferKeep(fieldA, fieldB, 'VIOLA');
+    if (violaPreference !== 0) {
+      return violaPreference;
+    }
+    return preferKeep(fieldA, fieldB, 'FIKKA');
+  }
+
+  function sortByRelatorTerm(fieldA, fieldB) {
+    // Should this be done to 6XX and 8XX fields as well? Does $t affect sorting?
+    if (!['700', '710', '711', '730'].includes(fieldA.tag)) {
+      return 0;
+    }
+
+
+    function fieldGetMaxRelatorTermScore(field) {
+      if (!field.subfields) {
+        return 0;
+      }
+      const e = field.subfields.filter(sf => sf.code === 'e');
+      const scores = e.map(sf => scoreRelatorTerm(sf.value));
+      //debugDev(`RELATOR SCORE FOR '${fieldToString(field)}': ${scores.join(', ')}`);
+      return Math.max(...scores);
+    }
+
+    const scoreA = fieldGetMaxRelatorTermScore(fieldA);
+    const scoreB = fieldGetMaxRelatorTermScore(fieldB);
+
+    if (scoreA < scoreB) {
+      return 1;
+    }
+    if (scoreA > scoreB) {
+      return -1;
+    }
+    return 0;
+  }
+
+  function fieldGetMinLinkAndSequenceNumber(field) {
+    if (!field.subfields) {
+      return BIG_BAD_NUMBER;
+    }
+    const relevantSubfields = field.subfields.filter(sf => isValidSubfield8(sf));
+    // If val is something like "1.2\x" parseFloat() would give a syntax erro because of hex-like escape sequnce (at least on Chrome). Thus remove tail:
+    const scores = relevantSubfields.map(sf => parseFloat(sf.value.replace(/\\.*$/u, '')));
+    if (scores.length === 0) {
+      return BIG_BAD_NUMBER;
+    }
+    return Math.min(...scores);
+  }
+
+  function sortByFieldLinkAndSequenceNumber(fieldA, fieldB) { // Sort by subfield $8 that is...
+    const scoreA = fieldGetMinLinkAndSequenceNumber(fieldA);
+    const scoreB = fieldGetMinLinkAndSequenceNumber(fieldB);
+    //debugDev(` sf-8-A-score for '${fieldToString(fieldA)}: ${scoreA}`);
+    //debugDev(` sf-8-B-score for '${fieldToString(fieldB)}: ${scoreB}`);
+    if (scoreA === scoreB) {
+      return 0;
+    }
+    if (scoreB === 0) {
+      return 1;
+    }
+    if (scoreA === 0) {
+      return -1;
+    }
+    if (scoreA > scoreB) { // smaller is better
+      return 1;
+    }
+    return -1;
+  }
+
+  function sortByOccurrenceNumber(fieldA, fieldB) { // Sort by subfield $6
+
+    function fieldGetOccurrenceNumber(field) { // should this function be exported? (based on validator sortRelatorFields.js)
+      if (!field.subfields) {
+        return 0;
+      }
+      const subfield6 = field.subfields.find(sf => isValidSubfield6(sf));
+      if (subfield6 === undefined) {
+        return 0;
+      }
+      return parseInt(subfield6GetOccurrenceNumber(subfield6), 10);
+    }
+
+    if (fieldA.tag !== '880') {
+      return 0;
+    }
+    const scoreA = fieldGetOccurrenceNumber(fieldA);
+    const scoreB = fieldGetOccurrenceNumber(fieldB);
+
+    //debugDev(`A: '${fieldToString(fieldA)}: ${scoreA}`);
+    //debugDev(`B: '${fieldToString(fieldB)}: ${scoreB}`);
+
+    if (scoreA === scoreB) {
+      return 0;
+    }
+    if (scoreB === 0) {
+      return -1;
+    }
+    if (scoreA === 0) {
+      return 1;
+    }
+    if (scoreA > scoreB) { // smaller is better
+      return 1;
+    }
+    return -1;
+  }
+
+  function sortAlphabetically(fieldA, fieldB) {
+    const tagToSortingSubfields = {
+      // '028': ['b', 'a']?
+      'LOW': ['a'],
+      'SID': ['c']
+    };
+
+    function scoreSubfieldsAlphabetically(setOfSubfields) {
+      if (setOfSubfields.length === 0) {
+        return 0;
+      }
+      const [subfieldCode, ...remainingSubfieldCodes] = setOfSubfields;
+      const valA = selectFirstValue(fieldA, subfieldCode);
+      const valB = selectFirstValue(fieldB, subfieldCode);
+      //debugDev(`CHECKING SUBFIELD '${subfieldCode}'`);
+      if (!valA) {
+        if (!valB) {
+          return scoreSubfieldsAlphabetically(remainingSubfieldCodes);
+        }
+        return -1;
+      }
+      if (!valB) {
+        return 1;
+      }
+      //debugDev(`CHECKING SUBFIELD '${subfieldCode}': '${valA}' vs '${valB}'`);
+
+      if (valA < valB) {
+        return -1;
+      }
+      if (valB < valA) {
+        return 1;
+      }
+      return scoreSubfieldsAlphabetically(remainingSubfieldCodes);
+    }
+
+    if (fieldA.tag === fieldB.tag) {
+      if (!(fieldA.tag in tagToSortingSubfields)) {
+        return 0;
+      }
+
+      const subfieldsToCheck = tagToSortingSubfields[fieldA.tag];
+
+      //debugDev(`CHECKING ${subfieldsToCheck.join(', ')}`);
+      const result = scoreSubfieldsAlphabetically(subfieldsToCheck);
+      //debugDev(`RESULT ${result}`);
+      return result;
+    }
+    return 0;
+  }
+
+  //-----------------------------------------------------------------------------
+
+
+  function selectFirstValue(field, subcode) {
+    return field.subfields
+      .filter(subfield => subcode === subfield.code)
+      .map(subfield => subfield.value)
+      .slice(0, 1);
+  }
+}
+

package/src/sortFields.spec.js

@@ -0,0 +1,52 @@
+import {expect} from 'chai';
+import {MarcRecord} from '@natlibfi/marc-record';
+import validatorFactory from './sortFields';
+import {READERS} from '@natlibfi/fixura';
+import generateTests from '@natlibfi/fixugen';
+import createDebugLogger from 'debug';
+
+generateTests({
+  callback,
+  path: [__dirname, '..', 'test-fixtures', 'sort-fields'],
+  useMetadataFile: true,
+  recurse: false,
+  fixura: {
+    reader: READERS.JSON
+  },
+  mocha: {
+    before: () => testValidatorFactory()
+  }
+});
+const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda/sortFields:test');
+
+async function testValidatorFactory() {
+  const validator = await validatorFactory();
+
+  expect(validator)
+    .to.be.an('object')
+    .that.has.any.keys('description', 'validate');
+
+  expect(validator.description).to.be.a('string');
+  expect(validator.validate).to.be.a('function');
+}
+
+async function callback({getFixture, enabled = true, fix = true}) {
+  if (enabled === false) {
+    debug('TEST SKIPPED!');
+    return;
+  }
+
+  const validator = await validatorFactory();
+  const record = new MarcRecord(getFixture('input.json'));
+  const expectedResult = getFixture('result.json');
+  // console.log(expectedResult); // eslint-disable-line
+
+  if (!fix) {
+    const result = await validator.validate(record);
+    expect(result).to.eql(expectedResult);
+    return;
+  }
+
+  await validator.fix(record);
+  expect(record).to.eql(expectedResult);
+}

package/src/sortRelatorTerms.js

@@ -6,38 +6,16 @@ import clone from 'clone';
 //import createDebugLogger from 'debug';
 import {fieldToString} from './utils';
 import {fieldFixPunctuation} from './punctuation2';
+import {relatorTermScore} from './sortFields';
 //const debug = createDebugLogger('@natlibfi/marc-record-validators-melinda:sortRelatorTerms');
 //const debugData = debug.extend('data');
 
 const WORST_WORK = 98;
 
-const relatorTermValues = { // The higher, the better
-  // More abstract, the earlier it appears.
-  // Note that terms with same abstraction level might also have order preferences
-  // work/teos > expression/ekspressio > manifestation/manifestaatio
-  'säveltäjä': 100,
-  'kirjoittaja': 99, // Viola wants composer/säveltäjä on top (highly unlikely to ever appear together, but...)
-  'taiteilija': 98,
-  'sanoittaja': 90,
-  // ekspressio
-  'sovittaja': 80,
-  'toimittaja': 80,
-  'kuvittaja': 75,
-  'editointi': 71,
-  'kääntäjä': 70,
-  'lukija': 61,
-  // manifestaatio
-  'esittäjä': 60,
-  'johtaja': 50,
-  'kustantaja': 41,
-  'julkaisija': 40
-
-};
-
 function scoreRelatorTerm(term) {
   const normalizedTerm = normalizeValue(term);
-  if (normalizedTerm in relatorTermValues) {
-    return relatorTermValues[normalizedTerm];
+  if (normalizedTerm in relatorTermScore) {
+    return relatorTermScore[normalizedTerm];
   }
   return 0;
 }

package/src/sortSubfields.js

@@ -15,17 +15,29 @@ const defaultSortOrderFinns = defaultSortOrderStringFinns.split('');
 const defaultSortOrderOthers = defaultSortOrderStringOthers.split('');
 
 
-export default function () {
+export default function (tagPattern) {
 
   return {
     description: 'Swap adjacent subfields',
     validate, fix
   };
 
-  function fix(record) {
+  function getRelevantFields(record, tagPattern) {
+    const datafields = record.fields.filter(f => f.subfields);
+    if (!tagPattern) {
+      return datafields;
+    }
+
+    const regexp = new RegExp(tagPattern, 'u');
+    return datafields.filter(f => regexp.test(f.tag));
+  }
+
+  function fix(record, tagPattern) {
     const res = {message: [], fix: [], valid: true};
 
-    record.fields.forEach(field => {
+    const relevantFields = getRelevantFields(record, tagPattern);
+
+    relevantFields.forEach(field => {
       sortAdjacentSubfields(field);
     });
 
@@ -35,7 +47,9 @@ export default function () {
   function validate(record) {
     const res = {message: []};
 
-    record.fields.forEach(field => {
+    const relevantFields = getRelevantFields(record, tagPattern);
+
+    relevantFields.forEach(field => {
       const clonedField = clone(field);
       sortAdjacentSubfields(clonedField);
       const clonedFieldAsString = fieldToString(clonedField);

package/src/sortSubfields.spec.js

@@ -30,7 +30,7 @@ async function testValidatorFactory() {
   expect(validator.validate).to.be.a('function');
 }
 
-async function callback({getFixture, enabled = true, fix = false}) {
+async function callback({getFixture, enabled = true, fix = false, tagPattern = false}) {
   if (enabled === false) {
     debug('TEST SKIPPED!');
     return;
@@ -42,11 +42,11 @@ async function callback({getFixture, enabled = true, fix = false}) {
   // console.log(expectedResult); // eslint-disable-line
 
   if (!fix) {
-    const result = await validator.validate(record);
+    const result = await validator.validate(record, tagPattern);
     expect(result).to.eql(expectedResult);
     return;
   }
 
-  await validator.fix(record);
+  await validator.fix(record, tagPattern);
   expect(record).to.eql(expectedResult);
 }

package/src/utils.js

@@ -73,3 +73,8 @@ export function getCatalogingLanguage(record) {
   }
   return b.value;
 }
+
+
+export function uniqArray(arr) {
+  return arr.filter((val, i) => arr.indexOf(val) === i);
+}

package/test-fixtures/remove-inferior-datafields/f01/expectedResult.json

@@ -2,6 +2,18 @@
   "_validationOptions": {},
   "fields": [
     { "tag": "001", "value": "f01" },
+
+    { "tag": "610", "ind1": "2", "ind2": "4", "subfields": [
+      { "code": "a", "value": "MELKEHITYS-2383a."},
+      { "code": "0", "value": "(FI_ASTERI-N)000111222" },
+      { "code": "9", "value": "FENNI<KEEP>" }
+    ]},
+
+    { "tag": "610", "ind1": "2", "ind2": "4", "subfields": [
+      { "code": "a", "value": "MELKEHITYS-2383b."},
+      { "code": "0", "value": "(FI_ASTERI-N)000111223" }
+    ]},
+
     { "tag": "653", "ind1": " ", "ind2": " ", "subfields": [
         { "code": "a", "value": "term"},
         { "code": "9", "value": "FENNI<KEEP>"}

package/test-fixtures/remove-inferior-datafields/f01/record.json

@@ -1,6 +1,25 @@
 {
   "fields": [
     { "tag": "001", "value": "f01" },
+
+    { "tag": "610", "ind1": "2", "ind2": "4", "subfields": [
+      { "code": "a", "value": "MELKEHITYS-2383a."},
+      { "code": "0", "value": "(FI_ASTERI-N)000111222" },
+      { "code": "9", "value": "FENNI<KEEP>" }
+    ]},
+    { "tag": "610", "ind1": "2", "ind2": "4", "subfields": [
+      { "code": "a", "value": "MELKEHITYS-2383a."}
+    ]},
+
+    { "tag": "610", "ind1": "2", "ind2": "4", "subfields": [
+      { "code": "a", "value": "MELKEHITYS-2383b."},
+      { "code": "0", "value": "(FI_ASTERI-N)000111223" }
+    ]},
+    { "tag": "610", "ind1": "2", "ind2": "4", "subfields": [
+      { "code": "a", "value": "MELKEHITYS-2383b."}
+    ]},
+
+
     { "tag": "653", "ind1": " ", "ind2": " ", "subfields": [ { "code": "a", "value": "term"} ]},
     { "tag": "653", "ind1": " ", "ind2": " ", "subfields": [
         { "code": "a", "value": "term"},

package/test-fixtures/sort-fields/01/input.json

@@ -0,0 +1,32 @@
+{
+  "leader": "12345cam a22002417i 4500",
+  "fields": [
+    {"tag": "001", "value": "000123456"},
+    {"tag": "003", "value": "(FI-MELINDA)"},
+    {"tag": "005", "value": "20210730133112.0"},
+    {"tag": "020", "ind1": " ", "ind2": " ", "subfields": [{"code": "a", "value": "123456789012X"}]},
+    {"tag": "100", "ind1": "1", "ind2": " ", "subfields": [{"code": "a", "value": "Sukunimi, Etunimi"}]},
+    {"tag": "245", "ind1": "1", "ind2": " ", "subfields": [{"code": "a", "value": "Nimeke."}]},
+    {"tag": "500", "ind1": " ", "ind2": " ", "subfields": [{"code": "a", "value": "Lorum ipsum."}]},
+    {"tag": "300", "ind1": " ", "ind2": " ", "subfields": [{"code": "a", "value": "1 nide (123 sivua)"}]},
+    {"tag": "FOO", "ind1": " ", "ind2": " ", "subfields": [{"code": "a", "value": "BAR"}]},
+    {"tag": "900", "ind1": " ", "ind2": " ", "subfields": [
+      {"code": "a", "value": "Auel, Jean M."},
+      {"code": "y", "value": "Untinen-Auel, Jean M."}
+    ]},
+
+    {"tag": "STA", "ind1": " ", "ind2": " ", "subfields": [{"code": "a", "value": "DELETED"}]},
+
+    {"tag": "SID", "ind1": " ", "ind2": " ", "subfields": [{"code": "b", "value": "123"}, {"code": "c", "value": "alma"}]},
+
+    {"tag": "LOW", "ind1": " ", "ind2": " ", "subfields": [{"code": "a", "value": "ALMA"}]},
+
+    {"tag": "CAT", "subfields": [
+      {"code": "a", "value": "CONV-ISBD"},
+      {"code": "b", "value": "30"},
+      {"code": "c", "value": "20090101"},
+      {"code": "l", "value": "FIN"},
+      {"code": "h", "value": "1205"}
+    ]}
+  ]
+}

package/test-fixtures/sort-fields/01/metadata.json

@@ -0,0 +1,5 @@
+{
+  "description": "Tag-based sorting (also SID, LOW, ...)",
+  "skip": false,
+  "only": false
+}

package/test-fixtures/sort-fields/01/result.json

@@ -0,0 +1,29 @@
+{
+  "leader": "12345cam a22002417i 4500",
+  "fields": [
+    {"tag": "001", "value": "000123456"},
+    {"tag": "STA", "ind1": " ", "ind2": " ", "subfields": [{"code": "a", "value": "DELETED"}]},
+    {"tag": "003", "value": "(FI-MELINDA)"},
+    {"tag": "005", "value": "20210730133112.0"},
+    {"tag": "020", "ind1": " ", "ind2": " ", "subfields": [{"code": "a", "value": "123456789012X"}]},
+    {"tag": "100", "ind1": "1", "ind2": " ", "subfields": [{"code": "a", "value": "Sukunimi, Etunimi"}]},
+    {"tag": "245", "ind1": "1", "ind2": " ", "subfields": [{"code": "a", "value": "Nimeke."}]},
+    {"tag": "300", "ind1": " ", "ind2": " ", "subfields": [{"code": "a", "value": "1 nide (123 sivua)"}]},
+    {"tag": "500", "ind1": " ", "ind2": " ", "subfields": [{"code": "a", "value": "Lorum ipsum."}]},
+    {"tag": "900", "ind1": " ", "ind2": " ", "subfields": [{"code": "a", "value": "Auel, Jean M."}, {"code": "y", "value": "Untinen-Auel, Jean M."}]},
+
+    {"tag": "SID", "ind1": " ", "ind2": " ", "subfields": [{"code": "b", "value": "123"}, {"code": "c", "value": "alma"}]},
+
+    {"tag": "LOW", "ind1": " ", "ind2": " ", "subfields": [{"code": "a", "value": "ALMA"}]},
+
+    {"tag": "CAT", "ind1": " ", "ind2": " ", "subfields": [
+      {"code": "a", "value": "CONV-ISBD"},
+      {"code": "b", "value": "30"},
+      {"code": "c", "value": "20090101"},
+      {"code": "l", "value": "FIN"},
+      {"code": "h", "value": "1205"}
+    ]},
+    {"tag": "FOO", "ind1": " ", "ind2": " ", "subfields": [{"code": "a", "value": "BAR"}]}
+  ],
+  "_validationOptions": {}
+}