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

package/tests/jest/components/WelcomePage.test.tsx

@@ -0,0 +1,43 @@
+import * as React from "react";
+import { render, screen } from "@testing-library/react";
+
+// Header pulls in the react-router v3 context a plain render does not supply, and
+// both Header and Footer are page chrome with no behavior worth exercising here.
+// Mock them to markers so the test stays about what WelcomePage composes.
+jest.mock("../../../src/components/Header", () => ({
+  __esModule: true,
+  default: () => <div data-testid="header" />,
+}));
+jest.mock("../../../src/components/Footer", () => ({
+  __esModule: true,
+  default: () => <div data-testid="footer" />,
+}));
+
+import WelcomePage from "../../../src/components/WelcomePage";
+
+describe("WelcomePage", () => {
+  it("shows the header", () => {
+    render(<WelcomePage />);
+    expect(screen.getByTestId("header")).toBeInTheDocument();
+  });
+
+  it("shows the welcome message", () => {
+    render(<WelcomePage />);
+    expect(
+      screen.getByRole("heading", {
+        name: "Welcome to the Circulation Admin Interface!",
+      })
+    ).toBeInTheDocument();
+  });
+
+  it("shows a link to the library create form", () => {
+    render(<WelcomePage />);
+    const link = screen.getByRole("link", { name: /create a new library/i });
+    expect(link).toHaveAttribute("href", "/admin/web/config/libraries/create");
+  });
+
+  it("shows the footer", () => {
+    render(<WelcomePage />);
+    expect(screen.getByTestId("footer")).toBeInTheDocument();
+  });
+});

package/tests/jest/components/WithEditButton.test.tsx

@@ -0,0 +1,55 @@
+import * as React from "react";
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+
+import WithEditButton from "../../../src/components/WithEditButton";
+
+describe("WithEditButton", () => {
+  it("shows children", () => {
+    render(
+      <WithEditButton disabled={false} onEdit={jest.fn()}>
+        child
+      </WithEditButton>
+    );
+
+    expect(screen.getByText("child")).toBeInTheDocument();
+  });
+
+  it("shows an edit button", () => {
+    render(
+      <WithEditButton disabled={false} onEdit={jest.fn()}>
+        child
+      </WithEditButton>
+    );
+
+    expect(screen.getByRole("button")).toHaveClass("edit-btn");
+  });
+
+  it("calls onEdit when clicked", async () => {
+    const user = userEvent.setup();
+    const onEdit = jest.fn();
+    render(
+      <WithEditButton disabled={false} onEdit={onEdit}>
+        child
+      </WithEditButton>
+    );
+
+    await user.click(screen.getByRole("button"));
+
+    expect(onEdit).toHaveBeenCalledTimes(1);
+  });
+
+  it("does nothing when disabled", async () => {
+    const user = userEvent.setup();
+    const onEdit = jest.fn();
+    render(
+      <WithEditButton disabled={true} onEdit={onEdit}>
+        child
+      </WithEditButton>
+    );
+
+    await user.click(screen.getByRole("button"));
+
+    expect(onEdit).not.toHaveBeenCalled();
+  });
+});

package/tests/jest/components/WithRemoveButton.test.tsx

@@ -0,0 +1,95 @@
+import * as React from "react";
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+
+import WithRemoveButton from "../../../src/components/WithRemoveButton";
+
+describe("WithRemoveButton", () => {
+  it("shows children", () => {
+    render(
+      <WithRemoveButton disabled={false} onRemove={jest.fn()}>
+        child
+      </WithRemoveButton>
+    );
+
+    expect(screen.getByText("child")).toBeInTheDocument();
+  });
+
+  it("shows a remove button", () => {
+    render(
+      <WithRemoveButton disabled={false} onRemove={jest.fn()}>
+        child
+      </WithRemoveButton>
+    );
+
+    expect(screen.getByRole("button")).toHaveClass("remove-btn");
+  });
+
+  it("calls onRemove when clicked", async () => {
+    const user = userEvent.setup();
+    const onRemove = jest.fn();
+    render(
+      <WithRemoveButton disabled={false} onRemove={onRemove}>
+        child
+      </WithRemoveButton>
+    );
+
+    await user.click(screen.getByRole("button"));
+
+    expect(onRemove).toHaveBeenCalledTimes(1);
+  });
+
+  it("does nothing when disabled", async () => {
+    const user = userEvent.setup();
+    const onRemove = jest.fn();
+    render(
+      <WithRemoveButton disabled={true} onRemove={onRemove}>
+        child
+      </WithRemoveButton>
+    );
+
+    await user.click(screen.getByRole("button"));
+
+    expect(onRemove).not.toHaveBeenCalled();
+  });
+
+  it("calls onRemove when confirmation returns true", async () => {
+    const user = userEvent.setup();
+    const onRemove = jest.fn();
+    const confirmRemoval = jest.fn().mockReturnValue(true);
+    render(
+      <WithRemoveButton
+        disabled={false}
+        onRemove={onRemove}
+        confirmRemoval={confirmRemoval}
+      >
+        child
+      </WithRemoveButton>
+    );
+
+    await user.click(screen.getByRole("button"));
+
+    expect(confirmRemoval).toHaveBeenCalledTimes(1);
+    expect(onRemove).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not call onRemove when confirmation returns false", async () => {
+    const user = userEvent.setup();
+    const onRemove = jest.fn();
+    const confirmRemoval = jest.fn().mockReturnValue(false);
+    render(
+      <WithRemoveButton
+        disabled={false}
+        onRemove={onRemove}
+        confirmRemoval={confirmRemoval}
+      >
+        child
+      </WithRemoveButton>
+    );
+
+    await user.click(screen.getByRole("button"));
+
+    expect(confirmRemoval).toHaveBeenCalledTimes(1);
+    expect(onRemove).not.toHaveBeenCalled();
+  });
+});

package/tests/jest/editorAdapter.test.ts

@@ -0,0 +1,245 @@
+import adapter from "../../src/editorAdapter";
+import {
+  OPDSEntry,
+  Contributor,
+  Series,
+  Category,
+  Summary,
+} from "opds-feed-parser";
+
+describe("editorAdapter", () => {
+  it("adapts valid OPDS entry", () => {
+    const entry = new OPDSEntry({
+      id: "id",
+      updated: "updated",
+      title: "title",
+      authors: [new Contributor({ name: "name", uri: "uri", role: "role" })],
+      subtitle: "subtitle",
+      contributors: [
+        new Contributor({ name: "name2", uri: "uri2", role: "role2" }),
+      ],
+      series: new Series({ name: "series", position: 2 }),
+      categories: [
+        new Category({ term: "term", scheme: "scheme", label: "label" }),
+        new Category({
+          term: "13-16",
+          scheme: "http://schema.org/typicalAgeRange",
+          label: "age",
+        }),
+        new Category({
+          term: "ya",
+          scheme: "http://schema.org/audience",
+          label: "ya",
+        }),
+        new Category({
+          term: "fiction",
+          scheme: "http://librarysimplified.org/terms/fiction/",
+          label: "Fiction",
+        }),
+      ],
+      identifiers: [],
+      links: [
+        {
+          href: "hide",
+          rel: "http://librarysimplified.org/terms/rel/hide",
+          type: "type",
+          title: "title",
+          role: "role",
+        },
+        {
+          href: "restore",
+          rel: "http://librarysimplified.org/terms/rel/restore",
+          type: "type",
+          title: "title",
+          role: "role",
+        },
+        {
+          href: "refresh",
+          rel: "http://librarysimplified.org/terms/rel/refresh",
+          type: "type",
+          title: "title",
+          role: "role",
+        },
+        {
+          href: "edit",
+          rel: "edit",
+          type: "type",
+          title: "title",
+          role: "role",
+        },
+        {
+          href: "issues",
+          rel: "issues",
+          type: "type",
+          title: "title",
+          role: "role",
+        },
+        {
+          href: "change-cover",
+          rel: "http://librarysimplified.org/terms/rel/change_cover",
+          type: "type",
+          title: "title",
+          role: "role",
+        },
+        {
+          href: "cover",
+          rel: "http://opds-spec.org/image",
+          type: "image/png",
+          title: "title",
+          role: "role",
+        },
+      ],
+      issued: "issued",
+      language: "language",
+      rights: "rights",
+      publisher: "publisher",
+      published: "published",
+      summary: new Summary({ content: "content", link: "link" }),
+      unparsed: {
+        "schema:alternativeHeadline": [{ _: "subtitle" }],
+        $: {
+          "schema:additionalType": { value: "medium" },
+        },
+        "bib:publisherImprint": [{ _: "imprint" }],
+        "schema:Rating": [
+          {
+            $: {
+              "schema:ratingValue": { value: "0.3" },
+              "schema:additionalType": {
+                value: "http://librarysimplified.org/terms/rel/quality",
+              },
+            },
+          },
+          {
+            $: {
+              "schema:ratingValue": { value: "4" },
+              "schema:additionalType": {
+                value: "http://schema.org/ratingValue",
+              },
+            },
+          },
+        ],
+      },
+    });
+
+    const adapted = adapter(entry);
+    expect(adapted.title).toBe("title");
+    expect(adapted.authors).toStrictEqual([
+      { name: "name", uri: "uri", role: "aut" },
+    ]);
+    // The adapter flattens `Contributor` instances into plain objects, so assert
+    // the shape it produces rather than comparing against `entry.contributors`.
+    expect(adapted.contributors).toStrictEqual([
+      { name: "name2", uri: "uri2", role: "role2" },
+    ]);
+    expect(adapted.subtitle).toBe("subtitle");
+    expect(adapted.summary).toBe("content");
+    expect(adapted.audience).toBe("ya");
+    expect(adapted.targetAgeRange).toStrictEqual(["13", "16"]);
+    expect(adapted.fiction).toBe(true);
+    expect(adapted.categories).toStrictEqual(["label", "age", "ya", "Fiction"]);
+    expect(adapted.hideLink).toStrictEqual(entry.links[0]);
+    expect(adapted.restoreLink).toStrictEqual(entry.links[1]);
+    expect(adapted.refreshLink).toStrictEqual(entry.links[2]);
+    expect(adapted.editLink).toStrictEqual(entry.links[3]);
+    expect(adapted.issuesLink).toStrictEqual(entry.links[4]);
+    expect(adapted.changeCoverLink).toStrictEqual(entry.links[5]);
+    expect(adapted.coverUrl).toBe(entry.links[6].href);
+    expect(adapted.series).toBe("series");
+    expect(adapted.seriesPosition).toBe(2);
+    expect(adapted.medium).toBe("medium");
+    expect(adapted.language).toBe("language");
+    expect(adapted.publisher).toBe("publisher");
+    expect(adapted.imprint).toBe("imprint");
+    expect(adapted.issued).toBe("issued");
+    expect(adapted.rating).toBe("4");
+  });
+
+  it("adapts visibility status from categories", () => {
+    const entry = new OPDSEntry({
+      id: "id",
+      updated: "updated",
+      title: "title",
+      subtitle: "subtitle",
+      authors: [],
+      contributors: [],
+      series: new Series({ name: "series", position: 2 }),
+      categories: [
+        new Category({ term: "term", scheme: "scheme", label: "label" }),
+        new Category({
+          term: "manually-suppressed",
+          scheme: "http://palaceproject.io/terms/visibility-status",
+          label: "Manually Suppressed",
+        }),
+      ],
+      identifiers: [],
+      links: [],
+      issued: "issued",
+      language: "language",
+      rights: "rights",
+      publisher: "publisher",
+      published: "published",
+      summary: new Summary({ content: "content", link: "link" }),
+      unparsed: {},
+    });
+
+    const adapted = adapter(entry);
+    expect(adapted.visibilityStatus).toBe("manually-suppressed");
+  });
+
+  it("adapts policy-filtered visibility status", () => {
+    const entry = new OPDSEntry({
+      id: "id",
+      updated: "updated",
+      title: "title",
+      subtitle: "subtitle",
+      authors: [],
+      contributors: [],
+      series: new Series({ name: "series", position: 2 }),
+      categories: [
+        new Category({
+          term: "policy-filtered",
+          scheme: "http://palaceproject.io/terms/visibility-status",
+          label: "Policy Filtered",
+        }),
+      ],
+      identifiers: [],
+      links: [],
+      issued: "issued",
+      language: "language",
+      rights: "rights",
+      publisher: "publisher",
+      published: "published",
+      summary: new Summary({ content: "content", link: "link" }),
+      unparsed: {},
+    });
+
+    const adapted = adapter(entry);
+    expect(adapted.visibilityStatus).toBe("policy-filtered");
+  });
+
+  it("doesn't crash when expected data is missing", () => {
+    const entry = new OPDSEntry({
+      id: "id",
+      updated: "updated",
+      title: "title",
+      subtitle: "subtitle",
+      authors: [],
+      contributors: [],
+      series: new Series({ name: "series", position: 2 }),
+      categories: [],
+      identifiers: [],
+      links: [],
+      issued: "issued",
+      language: "language",
+      rights: "rights",
+      publisher: "publisher",
+      published: "published",
+      summary: new Summary({ content: "content", link: "link" }),
+      unparsed: {},
+    });
+
+    const adapted = adapter(entry);
+    expect(adapted.title).toBe("title");
+  });
+});

package/tests/jest/index.test.tsx

@@ -0,0 +1,50 @@
+import * as React from "react";
+import * as ReactDOM from "react-dom";
+import { Router } from "react-router";
+
+import SetupPage from "../../src/components/SetupPage";
+
+// index.tsx does `export = CirculationAdmin`.
+const CirculationAdmin = require("../../src/index");
+
+/** Walk a React element tree for an element of the given type — the structural
+ *  analog of enzyme's `wrapper.find(Type)`, used where the tree is the app root
+ *  and there is no rendered DOM to query against. */
+function containsType(node: any, type: React.ElementType): boolean {
+  if (!node || typeof node !== "object") return false;
+  if (Array.isArray(node)) return node.some((n) => containsType(n, type));
+  if (node.type === type) return true;
+  return containsType(node.props && node.props.children, type);
+}
+
+describe("CirculationAdmin", () => {
+  let renderSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    // Capture what the bootstrap hands to ReactDOM.render without letting it
+    // paint into the jsdom document. We assert on the captured element tree
+    // (the structural analog of the original enzyme `wrapper.find(...)`); what
+    // SetupPage and the routed pages render is covered by their own tests.
+    renderSpy = jest
+      .spyOn(ReactDOM, "render")
+      .mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it("renders the setup page when setting up", () => {
+    new CirculationAdmin({ settingUp: true, csrfToken: "token" });
+
+    expect(renderSpy).toHaveBeenCalledTimes(1);
+    expect(containsType(renderSpy.mock.calls[0][0], SetupPage)).toBe(true);
+  });
+
+  it("renders the router otherwise", () => {
+    new CirculationAdmin({ csrfToken: "token" });
+
+    expect(renderSpy).toHaveBeenCalledTimes(1);
+    expect(containsType(renderSpy.mock.calls[0][0], Router)).toBe(true);
+  });
+});

package/tests/jest/legacy-setup.ts

@@ -0,0 +1,13 @@
+import { configure } from "enzyme";
+import * as Adapter from "enzyme-adapter-react-16";
+
+// Setup for the legacy enzyme + chai + sinon tests under `src/**/__tests__/`.
+// Replaces what `src/testHelper.ts` did for mocha. Delete alongside the last
+// enzyme test.
+
+configure({ adapter: new Adapter() });
+
+// Unhandled promise rejections are tolerated for these tests — see the comment in
+// `legacyJsdomEnvironment.js`. It cannot be done from here: jest hands test code a
+// *copy* of `process`, so a listener registered in this file never reaches the real
+// one that Node checks before throwing.

package/tests/jest/legacyJsdomEnvironment.js

@@ -0,0 +1,49 @@
+"use strict";
+
+const JSDOMEnvironment = require("jest-environment-jsdom").default;
+
+const warnUnhandledRejection = (reason) => {
+  console.warn("Unhandled promise rejection in a legacy test:", reason);
+};
+
+/**
+ * jsdom environment for the legacy enzyme tests. Delete it with the last one.
+ *
+ * Two things it restores that `src/testHelper.ts` used to provide under mocha:
+ *
+ * 1. `global.jsdom`. A handful of tests call `global.jsdom.reconfigure({ url })` to
+ *    change the page origin mid-test. `history.replaceState` is not a substitute —
+ *    they navigate across origins (`http://example.com`), which it cannot do.
+ *
+ * 2. Tolerance for unhandled promise rejections. Several suites stub a `fetch` that
+ *    rejects, and nothing awaits the result; the rejection surfaces after the test
+ *    has already passed. Mocha shrugged those off because its runner keeps an
+ *    `unhandledRejection` listener installed, and Node only throws when there are
+ *    none. Under jest they kill the worker and take the whole suite with them.
+ *
+ *    Re-arming has to happen on the `teardown` event, not in the constructor.
+ *    `jest-circus/globalErrorHandlers` reads `process.listeners()` off the sandbox's
+ *    *copied* `process` (always empty) but calls `removeAllListeners()` on the real
+ *    one. So any listener registered earlier is dropped at `setup` and "restored"
+ *    from an empty list, leaving zero listeners during the post-run window where
+ *    these rejections actually land.
+ *
+ *    Scoping this to the legacy environment keeps the modern `tests/jest/` suite
+ *    strict: jest clears listeners at each file's `setup`, and nothing re-arms one
+ *    for a project that does not use this environment.
+ */
+module.exports = class LegacyJSDOMEnvironment extends JSDOMEnvironment {
+  constructor(config, context) {
+    super(config, context);
+    this.global.jsdom = this.dom;
+  }
+
+  handleTestEvent(event) {
+    if (
+      event.name === "teardown" &&
+      process.listenerCount("unhandledRejection") === 0
+    ) {
+      process.on("unhandledRejection", warnUnhandledRejection);
+    }
+  }
+};