@thepalaceproject/circulation-admin 1.38.0 → 1.39.0-post.2

package/jest.config.js

@@ -4,6 +4,7 @@ module.exports = {
     "\\.(jpg|jpeg|png|gif|eot|otf|webp|svg|ttf|woff|woff2|mp4|webm|wav|mp3|m4a|aac|oga)$":
       "<rootDir>/tests/__mocks__/fileMock.js",
     "\\.(css|less)$": "<rootDir>/tests/__mocks__/styleMock.js",
+    "\\.md$": "<rootDir>/tests/__mocks__/fileMock.js",
   },
   preset: "ts-jest",
   testEnvironment: "jest-fixed-jsdom",

package/package.json

@@ -32,7 +32,8 @@
     "dev-server": "dotenv -c -- webpack serve --progress --hot --config webpack.dev-server.config",
     "dev-test-axe": "TEST_AXE=true npm run dev",
     "prod": "webpack --progress --config webpack.prod.config",
-    "build-docs": "typedoc --tsconfig tsconfig.json src"
+    "build-docs": "typedoc --tsconfig tsconfig.json src",
+    "sync-patron-blocking-docs": "node scripts/syncPatronBlockingDocs.js"
   },
   "dependencies": {
     "@nypl/dgx-svg-icons": "0.3.4",
@@ -105,7 +106,7 @@
     "fetch-mock-jest": "^1.5.1",
     "fetch-ponyfill": "^7.1.0",
     "file-loader": "^6.2.0",
-    "follow-redirects": "^1.15.6",
+    "follow-redirects": "^1.16.0",
     "husky": "^4.3.0",
     "jest": "^29.3.1",
     "jest-environment-jsdom": "^29.3.1",
@@ -113,6 +114,7 @@
     "jsdom": "^20.0.3",
     "json-loader": "^0.5.4",
     "lint-staged": "^10.4.0",
+    "marked": "^17.0.6",
     "mini-css-extract-plugin": "1.6.0",
     "mocha": "^10.2.0",
     "msw": "^2.7.3",
@@ -152,5 +154,5 @@
     "*.{js,jsx,ts,tsx,css,md}": "prettier --write",
     "*.{js,css,md}": "prettier --write"
   },
-  "version": "1.38.0"
+  "version": "1.39.0-post.2"
 }

package/scripts/syncPatronBlockingDocs.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+/* eslint-disable @typescript-eslint/no-var-requires */
+/**
+ * Reads ../circulation/docs/FUNCTIONS.md, converts it to HTML, and writes
+ * src/content/patronBlockingFunctionsHtml.ts — a TypeScript module that
+ * exports the HTML as a string constant.
+ *
+ * Run via:  npm run sync-patron-blocking-docs
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { marked } = require("marked");
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+const srcMd = path.resolve(__dirname, "../../circulation/docs/FUNCTIONS.md");
+const destTs = path.resolve(
+  __dirname,
+  "../src/content/patronBlockingFunctionsHtml.ts"
+);
+
+if (!fs.existsSync(srcMd)) {
+  console.error(`Source not found: ${srcMd}`);
+  process.exit(1);
+}
+
+const markdown = fs.readFileSync(srcMd, "utf8");
+const html = marked(markdown);
+
+const tsContent = `// AUTO-GENERATED — do not edit by hand.
+// Run \`npm run sync-patron-blocking-docs\` to regenerate from
+// circulation/docs/FUNCTIONS.md.
+const patronBlockingFunctionsHtml = ${JSON.stringify(html)};
+export default patronBlockingFunctionsHtml;
+`;
+
+fs.mkdirSync(path.dirname(destTs), { recursive: true });
+fs.writeFileSync(destTs, tsContent, "utf8");
+console.log(`Written: ${destTs}`);

package/tests/jest/api/patronBlockingRules.test.ts

@@ -1,5 +1,8 @@
 import * as fetchMock from "fetch-mock-jest";
-import { validatePatronBlockingRuleExpression } from "../../../src/api/patronBlockingRules";
+import {
+  validatePatronBlockingRuleExpression,
+  ValidationResult,
+} from "../../../src/api/patronBlockingRules";
 import { PatronBlockingRule } from "../../../src/interfaces";
 
 const VALIDATE_URL = "/admin/patron_auth_service_validate_patron_blocking_rule";
@@ -21,7 +24,24 @@ describe("validatePatronBlockingRuleExpression", () => {
       sampleRule,
       "test-token"
     );
-    expect(result).toBeNull();
+    expect(result.error).toBeNull();
+  });
+
+  it("returns available_fields from a 200 response with a body", async () => {
+    fetchMock.post(VALIDATE_URL, {
+      status: 200,
+      body: { available_fields: { fines: 0, patron_identifier: "X123" } },
+    });
+    const result: ValidationResult = await validatePatronBlockingRuleExpression(
+      42,
+      sampleRule,
+      "test-token"
+    );
+    expect(result.error).toBeNull();
+    expect(result.availableFields).toEqual({
+      fines: 0,
+      patron_identifier: "X123",
+    });
   });
 
   it("returns the detail string from a 400 response", async () => {
@@ -34,7 +54,8 @@ describe("validatePatronBlockingRuleExpression", () => {
       sampleRule,
       "test-token"
     );
-    expect(result).toBe("Unknown placeholder: {unknown_field}");
+    expect(result.error).toBe("Unknown placeholder: {unknown_field}");
+    expect(result.availableFields).toBeNull();
   });
 
   it("returns a fallback string when a 400 response body has no detail", async () => {
@@ -44,8 +65,9 @@ describe("validatePatronBlockingRuleExpression", () => {
       sampleRule,
       "test-token"
     );
-    expect(result).not.toBeNull();
-    expect(typeof result).toBe("string");
+    expect(result.error).not.toBeNull();
+    expect(typeof result.error).toBe("string");
+    expect(result.availableFields).toBeNull();
   });
 
   it("sends the correct URL, method, and CSRF header", async () => {
@@ -73,6 +95,6 @@ describe("validatePatronBlockingRuleExpression", () => {
       expect.objectContaining({ method: "POST" })
     );
     // Server would return an error detail in a real call; here it returns 200 (mocked)
-    expect(result).toBeNull();
+    expect(result.error).toBeNull();
   });
 });

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

@@ -79,7 +79,56 @@ describe("CollectionImportButton", () => {
       screen.getByRole("button", { name: "Queue Import" })
     ).toBeInTheDocument();
     expect(screen.getByRole("checkbox")).toBeInTheDocument();
-    expect(screen.getByText("Force full re-import")).toBeInTheDocument();
+    expect(screen.getByLabelText("Force full re-import")).toBeInTheDocument();
+  });
+
+  it("shows compact summary by default; detailed docs are hidden", async () => {
+    const user = userEvent.setup();
+    renderButton();
+    await expandPanel(user);
+    expect(
+      screen.getByText(/queue import picks up new and changed items/i)
+    ).toBeInTheDocument();
+    expect(
+      screen.getByText(/schedules a background import job/i)
+    ).not.toBeVisible();
+    expect(
+      screen.getByText(/the import job re-processes every item/i)
+    ).not.toBeVisible();
+  });
+
+  it("clicking 'More details' reveals the detailed docs", async () => {
+    const user = userEvent.setup();
+    renderButton();
+    await expandPanel(user);
+
+    const details = screen.getByText("More details").closest("details");
+    expect(details).not.toHaveAttribute("open");
+
+    await user.click(screen.getByText("More details"));
+
+    expect(details).toHaveAttribute("open");
+    expect(
+      screen.getByText(/schedules a background import job/i)
+    ).toBeVisible();
+    expect(
+      screen.getByText(/the import job re-processes every item/i)
+    ).toBeVisible();
+  });
+
+  it("clicking 'More details' again hides the detailed docs", async () => {
+    const user = userEvent.setup();
+    renderButton();
+    await expandPanel(user);
+
+    await user.click(screen.getByText("More details"));
+    expect(
+      screen.getByText(/schedules a background import job/i)
+    ).toBeVisible();
+
+    await user.click(screen.getByText("More details"));
+    const details = screen.getByText("More details").closest("details");
+    expect(details).not.toHaveAttribute("open");
   });
 
   it("checkbox toggles force state", async () => {
@@ -94,6 +143,41 @@ describe("CollectionImportButton", () => {
     expect(checkbox).not.toBeChecked();
   });
 
+  it("button text changes to 'Queue Full Re-import' when force is checked", async () => {
+    const user = userEvent.setup();
+    renderButton();
+    await expandPanel(user);
+
+    expect(
+      screen.getByRole("button", { name: "Queue Import" })
+    ).toBeInTheDocument();
+
+    await user.click(screen.getByRole("checkbox"));
+
+    expect(
+      screen.getByRole("button", { name: "Queue Full Re-import" })
+    ).toBeInTheDocument();
+    expect(
+      screen.queryByRole("button", { name: "Queue Import" })
+    ).not.toBeInTheDocument();
+  });
+
+  it("button uses force class when force is checked", async () => {
+    const user = userEvent.setup();
+    renderButton();
+    await expandPanel(user);
+
+    const button = screen.getByRole("button", { name: "Queue Import" });
+    expect(button).not.toHaveClass("force");
+
+    await user.click(screen.getByRole("checkbox"));
+
+    const forceButton = screen.getByRole("button", {
+      name: "Queue Full Re-import",
+    });
+    expect(forceButton).toHaveClass("force");
+  });
+
   it("button triggers import with correct args (force=false)", async () => {
     const user = userEvent.setup();
     const { importCollection } = renderButton();
@@ -109,18 +193,39 @@ describe("CollectionImportButton", () => {
     await expandPanel(user);
     const checkbox = screen.getByRole("checkbox");
     await user.click(checkbox);
-    const button = screen.getByRole("button", { name: "Queue Import" });
+    const button = screen.getByRole("button", {
+      name: "Queue Full Re-import",
+    });
     await user.click(button);
     expect(importCollection).toHaveBeenCalledWith(42, true);
   });
 
-  it("shows success feedback with alert-success styling after import", async () => {
+  it("shows success feedback for regular import", async () => {
     const user = userEvent.setup();
     renderButton();
     await expandPanel(user);
     await user.click(screen.getByRole("button", { name: "Queue Import" }));
     await waitFor(() => {
-      const feedback = screen.getByText("Import task queued.");
+      const feedback = screen.getByText(
+        /import task queued\. new and updated items will appear/i
+      );
+      expect(feedback).toBeInTheDocument();
+      expect(feedback).toHaveClass("alert", "alert-success");
+    });
+  });
+
+  it("shows success feedback for force re-import", async () => {
+    const user = userEvent.setup();
+    renderButton();
+    await expandPanel(user);
+    await user.click(screen.getByRole("checkbox"));
+    await user.click(
+      screen.getByRole("button", { name: "Queue Full Re-import" })
+    );
+    await waitFor(() => {
+      const feedback = screen.getByText(
+        /full re-import task queued\. all items will be re-processed/i
+      );
       expect(feedback).toBeInTheDocument();
       expect(feedback).toHaveClass("alert", "alert-success");
     });
@@ -150,9 +255,13 @@ describe("CollectionImportButton", () => {
     await user.click(checkbox);
     expect(checkbox).toBeChecked();
 
-    await user.click(screen.getByRole("button", { name: "Queue Import" }));
+    await user.click(
+      screen.getByRole("button", { name: "Queue Full Re-import" })
+    );
     await waitFor(() => {
-      expect(screen.getByText("Import task queued.")).toBeInTheDocument();
+      expect(
+        screen.getByText(/full re-import task queued/i)
+      ).toBeInTheDocument();
     });
 
     const nextCollection: CollectionData = {
@@ -171,7 +280,9 @@ describe("CollectionImportButton", () => {
 
     await waitFor(() => {
       expect(screen.getByRole("checkbox")).not.toBeChecked();
-      expect(screen.queryByText("Import task queued.")).not.toBeInTheDocument();
+      expect(
+        screen.queryByText(/full re-import task queued/i)
+      ).not.toBeInTheDocument();
     });
   });
 
@@ -204,4 +315,31 @@ describe("CollectionImportButton", () => {
       ).toBeEnabled();
     });
   });
+
+  it("shows 'Queuing Full Re-import...' while importing with force", async () => {
+    const user = userEvent.setup();
+    let resolveImport: () => void;
+    const pendingImport = new Promise<void>((resolve) => {
+      resolveImport = resolve;
+    });
+    const mockImport = jest.fn().mockReturnValue(pendingImport);
+    renderButton({ importCollection: mockImport });
+    await expandPanel(user);
+
+    await user.click(screen.getByRole("checkbox"));
+    await user.click(
+      screen.getByRole("button", { name: "Queue Full Re-import" })
+    );
+
+    expect(
+      screen.getByRole("button", { name: "Queuing Full Re-import..." })
+    ).toBeDisabled();
+
+    resolveImport();
+    await waitFor(() => {
+      expect(
+        screen.getByRole("button", { name: "Queue Full Re-import" })
+      ).toBeEnabled();
+    });
+  });
 });

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

@@ -0,0 +1,220 @@
+import * as React from "react";
+import { fireEvent } from "@testing-library/react";
+import { Collections } from "../../../src/components/Collections";
+import renderWithContext from "../testUtils/renderWithContext";
+import {
+  CollectionsData,
+  ConfigurationSettings,
+} from "../../../src/interfaces";
+import { defaultFeatureFlags } from "../../../src/utils/featureFlags";
+
+// NB: This adds tests to the already existing tests in:
+// - `src/components/__tests__/Collections-test.tsx`.
+//
+// Those tests should eventually be migrated here and
+// adapted to the Jest/React Testing Library paradigm.
+
+describe("Collections - associated library disclosure", () => {
+  // ── Shared fixtures ───────────────────────────────────────────────────────
+
+  const allLibraries = [
+    { short_name: "gamma", name: "Gamma Library", uuid: "uuid-gamma" },
+    { short_name: "alpha", name: "Alpha Library", uuid: "uuid-alpha" },
+    { short_name: "beta", name: "Beta Library", uuid: "uuid-beta" },
+    { short_name: "delta", name: "Delta Library" }, // no uuid
+  ];
+
+  const sysAdminConfig: Partial<ConfigurationSettings> = {
+    csrfToken: "",
+    featureFlags: defaultFeatureFlags,
+    roles: [{ role: "system" }],
+  };
+
+  const renderCollections = (data: Partial<CollectionsData>) =>
+    renderWithContext(
+      <Collections
+        data={
+          {
+            collections: [],
+            protocols: [],
+            allLibraries,
+            ...data,
+          } as CollectionsData
+        }
+        fetchData={jest.fn()}
+        editItem={jest.fn().mockResolvedValue(undefined)}
+        deleteItem={jest.fn().mockResolvedValue(undefined)}
+        registerLibrary={jest.fn().mockResolvedValue(undefined)}
+        importCollection={jest.fn().mockResolvedValue(undefined)}
+        csrfToken="token"
+        isFetching={false}
+      />,
+      sysAdminConfig
+    );
+
+  // ── Toggle visibility ─────────────────────────────────────────────────────
+
+  it("shows no toggle for a collection without a libraries field", () => {
+    const { container } = renderCollections({
+      collections: [{ id: 1, protocol: "p", name: "My Collection" } as any],
+    });
+    expect(container.querySelector(".association-toggle")).toBeNull();
+    expect(container.querySelector(".library-count")).toBeNull();
+  });
+
+  it("shows a disabled toggle and 'no libraries' for a collection with an empty libraries array", () => {
+    const { container } = renderCollections({
+      collections: [
+        { id: 1, protocol: "p", name: "My Collection", libraries: [] } as any,
+      ],
+    });
+    const toggle = container.querySelector<HTMLButtonElement>(
+      ".association-toggle"
+    );
+    expect(toggle).not.toBeNull();
+    expect(toggle.disabled).toBe(true);
+    expect(container.querySelector(".library-count").textContent).toBe(
+      " (no libraries)"
+    );
+  });
+
+  it("shows '1 library' for a collection with one associated library", () => {
+    const { container } = renderCollections({
+      collections: [
+        {
+          id: 1,
+          protocol: "p",
+          name: "My Collection",
+          libraries: [{ short_name: "alpha" }],
+        } as any,
+      ],
+    });
+    const toggle = container.querySelector<HTMLButtonElement>(
+      ".association-toggle"
+    );
+    expect(toggle.disabled).toBe(false);
+    expect(container.querySelector(".library-count").textContent).toBe(
+      " (1 library)"
+    );
+  });
+
+  it("shows 'N libraries' for a collection with multiple associated libraries", () => {
+    const { container } = renderCollections({
+      collections: [
+        {
+          id: 1,
+          protocol: "p",
+          name: "My Collection",
+          libraries: [
+            { short_name: "alpha" },
+            { short_name: "beta" },
+            { short_name: "gamma" },
+          ],
+        } as any,
+      ],
+    });
+    expect(container.querySelector(".library-count").textContent).toBe(
+      " (3 libraries)"
+    );
+  });
+
+  // ── Expand / collapse ─────────────────────────────────────────────────────
+
+  it("expands the library list on toggle click and collapses on a second click", () => {
+    const { container } = renderCollections({
+      collections: [
+        {
+          id: 1,
+          protocol: "p",
+          name: "My Collection",
+          libraries: [{ short_name: "alpha" }, { short_name: "beta" }],
+        } as any,
+      ],
+    });
+    const toggle = container.querySelector(".association-toggle");
+    expect(container.querySelector(".associated-items")).toBeNull();
+    fireEvent.click(toggle);
+    expect(container.querySelector(".associated-items")).not.toBeNull();
+    fireEvent.click(toggle);
+    expect(container.querySelector(".associated-items")).toBeNull();
+  });
+
+  // ── allLibraries injection from mapStateToProps ───────────────────────────
+
+  it("resolves library display names from allLibraries", () => {
+    const { container } = renderCollections({
+      collections: [
+        {
+          id: 1,
+          protocol: "p",
+          name: "My Collection",
+          libraries: [{ short_name: "alpha" }, { short_name: "beta" }],
+        } as any,
+      ],
+    });
+    fireEvent.click(container.querySelector(".association-toggle"));
+
+    const items = container.querySelectorAll(".associated-items li");
+    // Sorted alphabetically: Alpha, Beta
+    expect(items[0].textContent).toBe("Alpha Library");
+    expect(items[1].textContent).toBe("Beta Library");
+  });
+
+  it("links a library name to its config page when a uuid is available", () => {
+    const { container } = renderCollections({
+      collections: [
+        {
+          id: 1,
+          protocol: "p",
+          name: "My Collection",
+          libraries: [{ short_name: "alpha" }],
+        } as any,
+      ],
+    });
+    fireEvent.click(container.querySelector(".association-toggle"));
+
+    const link = container.querySelector<HTMLAnchorElement>(
+      ".associated-items a"
+    );
+    expect(link).not.toBeNull();
+    expect(link.textContent).toBe("Alpha Library");
+    expect(link.href).toContain("/admin/web/config/libraries/edit/uuid-alpha");
+  });
+
+  it("renders a library without a uuid as plain text", () => {
+    const { container } = renderCollections({
+      collections: [
+        {
+          id: 1,
+          protocol: "p",
+          name: "My Collection",
+          libraries: [{ short_name: "delta" }],
+        } as any,
+      ],
+    });
+    fireEvent.click(container.querySelector(".association-toggle"));
+
+    expect(container.querySelector(".associated-items a")).toBeNull();
+    expect(container.querySelector(".associated-items li").textContent).toBe(
+      "Delta Library"
+    );
+  });
+
+  it("falls back to short_name when the library is not in allLibraries", () => {
+    const { container } = renderCollections({
+      collections: [
+        {
+          id: 1,
+          protocol: "p",
+          name: "My Collection",
+          libraries: [{ short_name: "unknown" }],
+        } as any,
+      ],
+    });
+    fireEvent.click(container.querySelector(".association-toggle"));
+
+    expect(container.querySelector(".associated-items li").textContent).toBe(
+      "unknown"
+    );
+  });
+});