@natlibfi/marc-record/dist/index.test.js

MARC record implementation in JavaScript

import generateTests from "@natlibfi/fixugen";
import { READERS } from "@natlibfi/fixura";
import { describe, it } from "node:test";
import assert from "node:assert";
import createDebugLogger from "debug";
import { MarcRecord } from "./index.js";
const debug = createDebugLogger("@natlibfi/marc-record/index.spec.js");
describe("index", () => {
  generateTests({
    callback,
    path: [import.meta.dirname, "..", "test-fixtures", "index"],
    useMetadataFile: true,
    recurse: true,
    fixura: {
      reader: READERS.JSON,
      failWhenNotFound: true
    },
    hooks: {
      beforeEach: () => {
        MarcRecord.setValidationOptions({});
      }
    }
  });
  function callback(metadata) {
    const { getFixture } = metadata;
    const { input, result, immutable, noinput, validationOptions } = metadata;
    const inputRecord = noinput ? null : getRecord(input, "input.json");
    const record = inputRecord ? MarcRecord.clone(inputRecord, validationOptions) : null;
    MarcRecord.setValidationOptions({ fields: false, subfields: false, subfieldValues: false });
    const outputRecord = immutable ? inputRecord : getRecord(result, "result.json");
    MarcRecord.setValidationOptions({});
    const { operations, returns, throws } = metadata;
    checkResults(operations, throws, returns);
    assert.deepStrictEqual(record, outputRecord);
    return;
    function checkResults(operations2, throws2, returns2) {
      if (throws2) {
        try {
          return runOps();
        } catch (error) {
          assert.equal(Object.hasOwn(error, "message"), true);
          assert.equal(Object.hasOwn(error, "validationResults"), true);
          assert.match(error.message, new RegExp(`^${throws2}`, "u"));
        }
        return;
      }
      const result2 = runOps();
      if (returns2 === void 0) {
        return;
      }
      assert.deepEqual(result2, returns2);
      function runOps() {
        return operations2.reduce((_, op) => runOperation(op), record);
      }
    }
    function getRecord(fromMeta, filename) {
      const data = fromMeta || getFixture(filename);
      if (Array.isArray(data)) {
        const text = data.join("\n");
        return MarcRecord.fromString(text, validationOptions);
      }
      return new MarcRecord(data, validationOptions);
    }
    function runOperation(op) {
      const { name, args } = op;
      if (name === "nop") {
        return record;
      }
      if (name === "insertField") {
        assert.equal(record.insertField(args), record);
        return record;
      }
      if (name === "insertFields") {
        assert.equal(record.insertFields(args), record);
        return record;
      }
      if (name === "appendField") {
        assert.equal(record.appendField(args), record);
        return record;
      }
      if (name === "appendFields") {
        assert.equal(record.appendFields(args), record);
        return record;
      }
      if (name === "removeField") {
        const what = (function(args2) {
          const { string, field, regexp, index } = args2;
          if (string || field) {
            return string || field;
          }
          if (regexp) {
            return new RegExp(regexp, "u");
          }
          if (index !== void 0) {
            return record.fields[index];
          }
          throw new Error(`No arg for ${name}(): ${JSON.stringify(args2, null, 2)}`);
        })(args);
        assert.equal(record.removeField(what), record);
        return record;
      }
      if (name === "removeFields") {
        const what = (function(args2) {
          const { getRegExp } = args2;
          if (getRegExp) {
            return record.get(new RegExp(getRegExp, "u"));
          }
          throw new Error(`No arg for ${name}(): ${JSON.stringify(args2, null, 2)}`);
        })(args);
        assert.equal(record.removeFields(what), record);
        return record;
      }
      if (name === "removeSubfield") {
        const field = record.fields[args.field];
        const subfield = field.subfields[args.subfield];
        assert.equal(record.removeSubfield(subfield, field), record);
        return record;
      }
      if (["get", "pop"].includes(name)) {
        const what = (function(args2) {
          const { string, regexp } = args2;
          if (string) {
            return string;
          }
          if (regexp) {
            return new RegExp(regexp, "u");
          }
          throw new Error(`No arg for ${name}(): ${JSON.stringify(args2, null, 2)}`);
        })(args);
        if (name === "pop") {
          return record.pop(what);
        }
        return record.get(what);
      }
      if (name === "getControlfields") {
        return record.getControlfields();
      }
      if (name === "getDatafields") {
        return record.getDatafields();
      }
      if (name === "getValidationOptions") {
        return MarcRecord.getValidationOptions();
      }
      if (name === "setValidationOptions") {
        return MarcRecord.setValidationOptions(args);
      }
      if (name === "getValidationErrors") {
        return record.getValidationErrors();
      }
      if (name === "MarcRecord") {
        const { leader, fields, validationOptions: validationOptions2 } = args ?? {};
        const object = args && { leader, fields };
        const created = new MarcRecord(object, validationOptions2);
        assert.equal(typeof created, "object");
        assert.ok(object === void 0 || created.fields !== object.fields);
        return created;
      }
      if (name === "clone") {
        const { validationOptions: validationOptions2 = {} } = args ?? {};
        const cloned = MarcRecord.clone(record, validationOptions2);
        assert.equal(Object.is(record, cloned), false);
        if (args === void 0 || args.validationOptions === void 0) {
          assert.deepStrictEqual(record, cloned);
          return cloned;
        }
        assert.deepStrictEqual(validationOptions2, cloned._validationOptions);
        assert.equal(record.leader, cloned.leader);
        assert.deepStrictEqual(record.fields, cloned.fields);
        return cloned;
      }
      if (name === "toString") {
        return record.toString().split("\n");
      }
      if (name === "toObject") {
        return record.toObject();
      }
      if (name === "equalsTo") {
        const what = (function(args2) {
          const { self, clone, string, object } = args2;
          if (self) {
            return record;
          }
          if (clone) {
            return MarcRecord.clone(record);
          }
          if (string) {
            return MarcRecord.fromString(string.join("\n"));
          }
          if (object) {
            return object;
          }
          const { leader, fields, validationOptions: validationOptions2 } = args2;
          return new MarcRecord({ leader, fields }, validationOptions2);
        })(args);
        const result2 = record.equalsTo(what);
        assert.equal(MarcRecord.isEqual(record, what), result2);
        return result2;
      }
      if (name === "getFields") {
        const { tag, value } = args;
        const fields = record.getFields(tag, value);
        assert.equal(record.containsFieldWithValue(tag, value), fields.length > 0);
        return fields;
      }
      if (name === "isTypeOfMaterial") {
        const { target } = args;
        if (target === "BK") {
          return record.isBK();
        }
        if (target === "CF") {
          return record.isCF();
        }
        if (target === "CR") {
          return record.isCR();
        }
        if (target === "MP") {
          return record.isMP();
        }
        if (target === "MU") {
          return record.isMU();
        }
        if (target === "MX") {
          return record.isMX();
        }
        if (target === "VM") {
          return record.isVM();
        }
        return false;
      }
      if (name === "getTypeOfMaterial") {
        return record.getTypeOfMaterial();
      }
      throw new Error(`Invalid operation: ${name}`);
    }
  }
});
//# sourceMappingURL=index.test.js.map