@thepalaceproject/circulation-admin 1.43.0 → 1.44.0-post.10

package/tests/jest/reducers/managePatrons.test.ts

@@ -0,0 +1,71 @@
+import ManagePatrons from "../../../src/reducers/managePatrons";
+import ActionCreator from "../../../src/actions";
+
+describe("ManagePatrons reducer", () => {
+  const initState = {
+    data: null,
+    isFetching: false,
+    isEditing: false,
+    fetchError: null,
+    formError: null,
+    responseBody: null,
+    successMessage: null,
+    isLoaded: false,
+  };
+
+  it("returns initial state for unrecognized action", () => {
+    expect(ManagePatrons(undefined, {})).toStrictEqual(initState);
+  });
+
+  it("handles CLEAR_PATRON_DATA_LOAD", () => {
+    const action = {
+      type: `${ActionCreator.CLEAR_PATRON_DATA}_LOAD`,
+      data: null,
+    };
+    const oldPatronState = {
+      url: "test url",
+      data: {
+        authorization_expires: "",
+        authorization_identifier: "1234",
+        authorization_identifiers: [],
+        block_reason: "",
+        external_type: "",
+        fines: "",
+        permanent_id: "1234",
+      },
+      isFetching: true,
+      fetchError: null,
+      editError: null,
+      isLoaded: true,
+      isEditing: false,
+    };
+    const oldErrorState = {
+      url: "test url",
+      data: null,
+      isFetching: true,
+      fetchError: {
+        status: 400,
+        response: "No patron found",
+        url: "",
+      },
+      editError: null,
+      isLoaded: true,
+      isEditing: false,
+    };
+
+    const newPatronState = Object.assign({}, oldPatronState, {
+      data: null,
+      isFetching: false,
+      isLoaded: true,
+    });
+    const newErrorState = Object.assign({}, oldErrorState, {
+      data: null,
+      isFetching: false,
+      isLoaded: true,
+      fetchError: null,
+    });
+
+    expect(ManagePatrons(oldPatronState, action)).toStrictEqual(newPatronState);
+    expect(ManagePatrons(oldErrorState, action)).toStrictEqual(newErrorState);
+  });
+});

package/tests/jest/testUtils/formDataShim.test.ts

@@ -0,0 +1,135 @@
+import { FormDataShim } from "./formDataShim";
+
+// Verifies the shim mirrors the browser's `new FormData(form)` "successful
+// controls" rules — the fidelity that makes the payload assertions in the form
+// suites (BookEditForm, SitewideAnnouncements, ...) trustworthy.
+describe("FormDataShim", () => {
+  const formWith = (html: string): HTMLFormElement => {
+    const form = document.createElement("form");
+    form.innerHTML = html;
+    return form;
+  };
+
+  it("includes named, enabled text controls", () => {
+    const data = new FormDataShim(
+      formWith(`<input name="title" value="Dune" />`)
+    );
+    expect(data.get("title")).toBe("Dune");
+  });
+
+  it("skips disabled controls, as the browser does", () => {
+    const data = new FormDataShim(
+      formWith(`<input name="title" value="Dune" disabled />`)
+    );
+    expect(data.get("title")).toBeNull();
+  });
+
+  it("skips unnamed controls", () => {
+    const data = new FormDataShim(formWith(`<input value="anon" />`));
+    expect(data.get("")).toBeNull();
+  });
+
+  it("skips controls disabled by an ancestor fieldset", () => {
+    // A control inside <fieldset disabled> is a non-successful control even
+    // though its own `disabled` property is false. (Attached to the document so
+    // the :disabled match resolves ancestry.)
+    const form = formWith(
+      `<fieldset disabled><input name="inside" value="x" /></fieldset>
+       <input name="outside" value="y" />`
+    );
+    document.body.appendChild(form);
+    try {
+      const data = new FormDataShim(form);
+      expect(data.get("inside")).toBeNull();
+      expect(data.get("outside")).toBe("y");
+    } finally {
+      form.remove();
+    }
+  });
+
+  it("includes a checkbox only when it is checked", () => {
+    expect(
+      new FormDataShim(
+        formWith(`<input type="checkbox" name="agree" value="yes" />`)
+      ).get("agree")
+    ).toBeNull();
+    expect(
+      new FormDataShim(
+        formWith(`<input type="checkbox" name="agree" value="yes" checked />`)
+      ).get("agree")
+    ).toBe("yes");
+  });
+
+  it("includes only the checked radio in a group", () => {
+    const data = new FormDataShim(
+      formWith(
+        `<input type="radio" name="size" value="s" />
+         <input type="radio" name="size" value="m" checked />`
+      )
+    );
+    expect(data.get("size")).toBe("m");
+  });
+
+  it("excludes submit/reset/button inputs", () => {
+    const data = new FormDataShim(
+      formWith(`<input type="submit" name="go" value="Save" />`)
+    );
+    expect(data.get("go")).toBeNull();
+  });
+
+  it("omits file inputs (the browser submits them as File objects)", () => {
+    // Deliberate divergence from real FormData: a value-reading shim can't
+    // reproduce a File, so file fields are treated as absent rather than sent
+    // as their string value. Pinned so a regression can't silently re-add them.
+    const data = new FormDataShim(formWith(`<input type="file" name="doc" />`));
+    expect(data.get("doc")).toBeNull();
+  });
+
+  it("includes every selected option of a multi-select", () => {
+    const form = document.createElement("form");
+    const select = document.createElement("select");
+    select.name = "langs";
+    select.multiple = true;
+    (
+      [
+        ["en", true],
+        ["fr", false],
+        ["de", true],
+      ] as const
+    ).forEach(([value, selected]) => {
+      const option = document.createElement("option");
+      option.value = value;
+      option.selected = selected;
+      select.appendChild(option);
+    });
+    form.appendChild(select);
+
+    expect(new FormDataShim(form).getAll("langs")).toStrictEqual(["en", "de"]);
+  });
+
+  it("supports the standard read/write surface", () => {
+    const data = new FormDataShim();
+    data.append("k", "1");
+    data.append("k", "2");
+    expect(data.getAll("k")).toStrictEqual(["1", "2"]);
+    expect(data.has("k")).toBe(true);
+    data.set("k", "3");
+    expect(data.getAll("k")).toStrictEqual(["3"]);
+    data.delete("k");
+    expect(data.has("k")).toBe(false);
+  });
+
+  it("set() replaces the first entry in place and drops later duplicates", () => {
+    const data = new FormDataShim();
+    data.append("a", "1");
+    data.append("b", "2");
+    data.append("a", "3");
+
+    data.set("a", "9");
+
+    expect(Array.from(data.entries())).toStrictEqual([
+      ["a", "9"],
+      ["b", "2"],
+    ]);
+  });
+});

package/tests/jest/testUtils/formDataShim.ts

@@ -0,0 +1,112 @@
+// The unit jsdom environment installs undici's `FormData`, which throws on
+// `new FormData(formElement)`. The reusable-components `Form` builds FormData
+// that way on submit, so tests that assert a submitted payload need a stand-in.
+//
+// This shim mirrors the browser's `new FormData(form)`: it serializes only
+// "successful controls" — named, non-disabled controls, with checkboxes and
+// radios contributing only when checked, submit/reset/button/image/file inputs
+// excluded, and every selected option of a multi-select included. A naive shim
+// that records *every* named control can make a payload assertion pass while the
+// real browser omits a disabled or unchecked field.
+export class FormDataShim {
+  private items: Array<[string, string]> = [];
+
+  constructor(form?: HTMLFormElement) {
+    if (!form) {
+      return;
+    }
+    // Serializes the form's own descendant controls; the forms under test don't
+    // associate external controls via `form="id"`, so those are not collected.
+    form
+      .querySelectorAll<
+        HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement
+      >("input, select, textarea")
+      .forEach((el) => {
+        // `:disabled` (not the `.disabled` property) so controls disabled via an
+        // ancestor `<fieldset disabled>` are omitted too, as the browser does.
+        if (!el.name || el.matches(":disabled")) {
+          return;
+        }
+        if (el instanceof HTMLInputElement) {
+          // Buttons never contribute a value. File inputs are omitted
+          // deliberately: the browser submits them as File objects, which a
+          // value-reading shim can't reproduce, so tests treat them as absent.
+          if (
+            ["submit", "reset", "button", "image", "file"].includes(el.type)
+          ) {
+            return;
+          }
+          if ((el.type === "checkbox" || el.type === "radio") && !el.checked) {
+            return;
+          }
+        }
+        if (el instanceof HTMLSelectElement && el.multiple) {
+          Array.from(el.selectedOptions).forEach((option) =>
+            this.items.push([el.name, option.value])
+          );
+          return;
+        }
+        this.items.push([el.name, el.value]);
+      });
+  }
+
+  get(key: string) {
+    const found = this.items.find(([k]) => k === key);
+    return found ? found[1] : null;
+  }
+  getAll(key: string) {
+    return this.items.filter(([k]) => k === key).map(([, v]) => v);
+  }
+  has(key: string) {
+    return this.items.some(([k]) => k === key);
+  }
+  append(key: string, value: string) {
+    this.items.push([key, value]);
+  }
+  set(key: string, value: string) {
+    // Replace the first matching entry in place and drop any later duplicates,
+    // preserving position as FormData.set does.
+    const firstIndex = this.items.findIndex(([k]) => k === key);
+    this.items = this.items.filter(([k]) => k !== key);
+    if (firstIndex === -1) {
+      this.items.push([key, value]);
+    } else {
+      this.items.splice(firstIndex, 0, [key, value]);
+    }
+  }
+  delete(key: string) {
+    this.items = this.items.filter(([k]) => k !== key);
+  }
+  forEach(
+    callback: (value: string, key: string, parent: FormDataShim) => void
+  ) {
+    this.items.forEach(([k, v]) => callback(v, k, this));
+  }
+  keys() {
+    return this.items.map(([k]) => k)[Symbol.iterator]();
+  }
+  values() {
+    return this.items.map(([, v]) => v)[Symbol.iterator]();
+  }
+  entries() {
+    return this.items
+      .map(([k, v]) => [k, v] as [string, string])
+      [Symbol.iterator]();
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+}
+
+// Swaps `window.FormData` for the shim around a suite, restoring it afterward.
+// Call once at the top level of a test file.
+export function installFormDataShim(): void {
+  let originalFormData: typeof FormData;
+  beforeAll(() => {
+    originalFormData = window.FormData;
+    (window as any).FormData = FormDataShim;
+  });
+  afterAll(() => {
+    (window as any).FormData = originalFormData;
+  });
+}

package/tests/jest/utils/sharedFunctions.test.ts

@@ -0,0 +1,121 @@
+import {
+  findDefault,
+  formatString,
+  isEqual,
+} from "../../../src/utils/sharedFunctions";
+
+describe("findDefault", () => {
+  const settingWithoutDefaults = {
+    key: "test_setting_no_default",
+    options: [
+      { key: "true", label: "Yes" },
+      { key: "false", label: "No" },
+    ],
+  };
+
+  const settingWithOneDefault = {
+    default: "true",
+    key: "test_setting_1_default",
+    options: [
+      { key: "true", label: "Yes" },
+      { key: "false", label: "No" },
+    ],
+  };
+
+  const settingWithMultipleDefaults = {
+    default: ["first default", "second default"],
+    key: "test_setting_mult_defaults",
+    options: [
+      { key: "first default", label: "Yes" },
+      { key: "no", label: "No" },
+      { key: "second default", label: "This one too" },
+      { key: "also no", label: "Not this one" },
+    ],
+  };
+
+  it("doesn't return anything if the setting has no default value", () => {
+    const result = findDefault(settingWithoutDefaults);
+    expect(result).toBeUndefined();
+  });
+
+  it("identifies the default setting from a list of options", () => {
+    const result = findDefault(settingWithOneDefault);
+    expect(result.length).toBe(1);
+    expect(result[0].key).toBe("true");
+    expect(result[0].label).toBe("Yes");
+  });
+
+  it("identifies multiple default settings from a list of options", () => {
+    const result = findDefault(settingWithMultipleDefaults);
+    expect(result.length).toBe(2);
+    expect(result[0].key).toBe("first default");
+    expect(result[0].label).toBe("Yes");
+    expect(result[1].key).toBe("second default");
+    expect(result[1].label).toBe("This one too");
+  });
+});
+
+describe("formatString", () => {
+  const stringToFormat = "this-is-a-sentence.";
+  it("capitalizes the first letter of a string by default", () => {
+    const result = formatString(stringToFormat);
+    expect(result).toBe("This-is-a-sentence.");
+  });
+
+  it("can be prevented from capitalizing", () => {
+    const result = formatString(stringToFormat, null, false);
+    expect(result).toBe("this-is-a-sentence.");
+  });
+
+  it("replaces characters", () => {
+    const result = formatString(stringToFormat, ["-", " "], false);
+    expect(result).toBe("this is a sentence.");
+  });
+
+  it("replaces characters and capitalizes", () => {
+    const result = formatString(stringToFormat, ["-", "!"]);
+    expect(result).toBe("This!is!a!sentence.");
+  });
+
+  it("replaces multiple characters", () => {
+    const result = formatString("need-to-replace!multiple-characters", [
+      "-",
+      "!",
+      " ",
+    ]);
+    expect(result).toBe("Need to replace multiple characters");
+  });
+
+  it("defaults to replacing characters with a space", () => {
+    const result = formatString(stringToFormat, ["-"]);
+    expect(result).toBe("This is a sentence.");
+  });
+});
+
+describe("isEqual", () => {
+  const arr1 = ["a", "b", "c"];
+
+  it("returns false if the arrays are not the same length", () => {
+    const arr2 = ["a", "b", "c", "d"];
+    expect(isEqual(arr1, arr2)).toBe(false);
+  });
+  it("returns false if the lengths are the same but not all of the elements match", () => {
+    const arr2 = ["a", "b", "d"];
+    expect(isEqual(arr1, arr2)).toBe(false);
+  });
+  it("returns false if there are duplicates", () => {
+    const arr2 = ["a", "a", "b"];
+    expect(isEqual(arr1, arr2)).toBe(false);
+  });
+  it("returns true if the arrays are the same", () => {
+    const arr2 = ["a", "b", "c"];
+    expect(isEqual(arr1, arr2)).toBe(true);
+  });
+  it("returns true even if the arrays do not list the elements in the same order", () => {
+    const arr2 = ["b", "c", "a"];
+    expect(isEqual(arr1, arr2)).toBe(true);
+  });
+  it("returns true if the arrays have the same duplicates", () => {
+    expect(isEqual(["a", "a", "b"], ["b", "a", "a"])).toBe(true);
+  });
+});

package/tsconfig.json

@@ -6,11 +6,10 @@
     "outDir": "lib",
     "lib": ["es2023.array","es2019", "dom"],
     "rootDir": ".",
-    // Mocha and jest are both used in this project. Certain globals are declared by both,
-    // such as describe, it, and test. Setting skipLibCheck to true prevents typescript from
-    // erroring when it sees duplicate variable declarations with different types.
+    // Some dependencies' type declarations (recharts, @open-draft/deferred-promise)
+    // do not compile under this project's `target` and `esModuleInterop` settings.
     "skipLibCheck": true,
-    "types": ["mocha", "node", "jest", "@testing-library/jest-dom"],
+    "types": ["node", "jest", "@testing-library/jest-dom"],
     "jsx": "react"
   },
   "exclude": [

package/testReporter.js

@@ -1,29 +0,0 @@
-const mocha = require("mocha");
-const sinon = require("sinon");
-const color = require("colors-cli/safe");
-
-function TestReporter(runner) {
-  // This isn't the place for warnings about soon-to-be-deprecated React methods, etc; we just want a clean list.
-  console.warn = sinon.stub();
-  console.error = sinon.stub();
-
-  const {
-    EVENT_SUITE_BEGIN,
-    EVENT_TEST_BEGIN,
-    EVENT_SUITE_END,
-  } = mocha.Runner.constants;
-
-  mocha.reporters.Base.call(this, runner);
-
-  runner.on(EVENT_SUITE_BEGIN, function (suite) {
-    console.group(color.x25.bold(suite.title));
-  });
-  runner.on(EVENT_TEST_BEGIN, function (test) {
-    console.log(test.title);
-  });
-  runner.on(EVENT_SUITE_END, function () {
-    console.groupEnd();
-  });
-}
-
-module.exports = TestReporter;

package/tests/jest/README.md

@@ -1,6 +0,0 @@
-# Jest Unit Tests
-
-This directory contains unit tests that run using jest. The directory structure should mirror that of the `src` tree.
-
-To run these tests, use the command `npm run test-jest`. These tests are executed along with the older mocha-based tests when `npm test` is run.
-To run a single test file, use the command `npm run test-jest-file [filename]`.