@thepalaceproject/circulation-admin 1.46.0 → 1.47.0-post.12

package/dist/circulation-admin.js.LICENSE.txt

@@ -142,4 +142,4 @@ object-assign
 
 //! momentjs.com
 
-//! version : 2.30.1
+//! version : 2.31.0

package/package.json

@@ -139,5 +139,5 @@
     "*.{js,jsx,ts,tsx,css,md}": "prettier --write",
     "*.{js,css,md}": "prettier --write"
   },
-  "version": "1.46.0"
+  "version": "1.47.0-post.12"
 }

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

@@ -52,6 +52,42 @@ describe("DiscoveryServices - registered library disclosure", () => {
 
   // ── Toggle visibility ─────────────────────────────────────────────────────
 
+  it("names registration data in the failed-library-list alert", () => {
+    // This tab's entries fall back to registration records, so the generic
+    // "shown by short name only" message would be wrong here.
+    const { container } = renderServices({
+      discovery_services: [{ id: 1, protocol: "p", name: "Service A" } as any],
+      allLibraries: [],
+      allLibrariesError: {
+        status: 500,
+        response: "nope",
+        url: "/admin/libraries",
+      },
+      libraryRegistrations: [
+        { id: 1, libraries: [{ short_name: "alpha", status: "success" }] },
+      ] as any,
+    });
+    expect(container.querySelector(".alert-danger")).toHaveTextContent(
+      "Registered libraries are shown using registration data"
+    );
+  });
+
+  it("shows no toggle while allLibraries has not settled", () => {
+    // Labels must render once, in final linked form, not flash bare short
+    // names that get rewritten when the sitewide list arrives.
+    const { container } = renderServices({
+      discovery_services: [{ id: 1, protocol: "p", name: "Service A" } as any],
+      allLibraries: undefined,
+      libraryRegistrations: [
+        {
+          id: 1,
+          libraries: [{ short_name: "alpha", status: "success" }],
+        },
+      ] as any,
+    });
+    expect(container.querySelector(".association-toggle")).toBeNull();
+  });
+
   it("shows no toggle when libraryRegistrations data has not yet loaded", () => {
     const { container } = renderServices({
       discovery_services: [{ id: 1, protocol: "p", name: "Service A" } as any],

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

@@ -23,6 +23,12 @@ describe("EditableConfigList - library association disclosure", () => {
   interface ServicesData {
     services: ServiceItem[];
     allLibraries?: Array<{ short_name: string; name?: string; uuid?: string }>;
+    allLibrariesError?: { status: number; response: string; url: string };
+    allLibrariesRefreshError?: {
+      status: number;
+      response: string;
+      url: string;
+    };
   }
 
   class TestEditForm extends React.Component<
@@ -36,6 +42,7 @@ describe("EditableConfigList - library association disclosure", () => {
   class TestServiceList extends EditableConfigList<ServicesData, ServiceItem> {
     EditForm = TestEditForm;
     listDataKey = "services";
+    usesLibraryList = true;
     itemTypeName = "service";
     urlBase = "/admin/services/";
     identifierKey = "id";
@@ -377,13 +384,19 @@ describe("EditableConfigList - library association disclosure", () => {
       expect(items[1].textContent).toBe("Beta Library - beta");
     });
 
-    it("falls back to short_name when allLibraries is absent from the data", () => {
+    it("shows an alert and bare short names when the library list failed to load", () => {
       const { container } = renderWithContext(
         <TestServiceList
           data={{
             services: [
               { id: 1, name: "Service A", libraries: [{ short_name: "nypl" }] },
             ],
+            allLibraries: [],
+            allLibrariesError: {
+              status: 500,
+              response: "nope",
+              url: "/admin/libraries",
+            },
           }}
           fetchData={jest.fn()}
           editItem={jest.fn().mockResolvedValue(undefined)}
@@ -393,11 +406,72 @@ describe("EditableConfigList - library association disclosure", () => {
         />,
         config
       );
+      expect(container.querySelector(".alert-danger")).toHaveTextContent(
+        "The library list failed to load"
+      );
+      // The associations still render, by short name, below the alert.
       fireEvent.click(container.querySelector(".association-toggle"));
       expect(container.querySelector(".associated-items li").textContent).toBe(
         "nypl"
       );
     });
+
+    it("shows a warning when the library list is stale", () => {
+      const { container } = renderWithContext(
+        <TestServiceList
+          data={{
+            services: [
+              { id: 1, name: "Service A", libraries: [{ short_name: "nypl" }] },
+            ],
+            allLibraries: [{ short_name: "nypl", name: "NYPL" }],
+            allLibrariesRefreshError: {
+              status: 500,
+              response: "nope",
+              url: "/admin/libraries",
+            },
+          }}
+          fetchData={jest.fn()}
+          editItem={jest.fn().mockResolvedValue(undefined)}
+          deleteItem={jest.fn().mockResolvedValue(undefined)}
+          csrfToken="token"
+          isFetching={false}
+        />,
+        config
+      );
+      expect(container.querySelector(".alert-warning")).toHaveTextContent(
+        "The library list could not be refreshed"
+      );
+      // The associations still render, from the retained list.
+      fireEvent.click(container.querySelector(".association-toggle"));
+      expect(container.querySelector(".associated-items li").textContent).toBe(
+        "NYPL - nypl"
+      );
+    });
+
+    it("holds the association panel until allLibraries settles", () => {
+      const { container } = renderWithContext(
+        <TestServiceList
+          data={{
+            services: [
+              { id: 1, name: "Service A", libraries: [{ short_name: "nypl" }] },
+            ],
+          }}
+          fetchData={jest.fn()}
+          editItem={jest.fn().mockResolvedValue(undefined)}
+          deleteItem={jest.fn().mockResolvedValue(undefined)}
+          csrfToken="token"
+          isFetching={false}
+        />,
+        config
+      );
+      // With the sitewide list unsettled, no toggle renders at all, so the
+      // panel cannot flash bare short names that get rewritten when the
+      // list arrives. The status line explains and announces the gap.
+      expect(container.querySelector(".association-toggle")).toBeNull();
+      expect(container.querySelector('[role="status"]')).toHaveTextContent(
+        "Loading libraries..."
+      );
+    });
   });
 });
 

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

@@ -202,6 +202,104 @@ describe("IndividualAdminEditForm - rendered inputs and role changes", () => {
   const roleCheckbox = (role: string) =>
     screen.getByRole("checkbox", { name: roleNames[role] });
 
+  const failureData = {
+    individualAdmins: [adminData],
+    allLibraries: [],
+    allLibrariesError: {
+      status: 500,
+      response: "nope",
+      url: "/admin/libraries",
+    },
+  };
+
+  it("waits for the library list before showing per-library roles", () => {
+    const { container } = renderForm({
+      item: adminData,
+      data: { individualAdmins: [adminData] },
+    });
+    expect(container.querySelector("table.library-admin-roles")).toBeNull();
+    expect(container.querySelector('[role="status"]')).toHaveTextContent(
+      "Loading libraries..."
+    );
+    // Sitewide toggles rewrite an existing admin's hidden per-library roles
+    // wholesale, so role edits are disabled until the list is available.
+    expect(roleCheckbox("system")).toBeDisabled();
+  });
+
+  it("explains a failed library list load when editing an existing admin", () => {
+    // On failure allLibraries settles to [] and allLibrariesError is set.
+    const { container } = renderForm({ item: adminData, data: failureData });
+    expect(
+      screen.getByText(
+        /library roles cannot be shown, and no roles can be changed/
+      )
+    ).toBeInTheDocument();
+    // The role="alert" danger Alert announces the failure itself, so the
+    // status region empties rather than duplicating the announcement.
+    expect(container.querySelector('[role="status"]')).toBeEmptyDOMElement();
+    expect(roleCheckbox("system")).toBeDisabled();
+    // All role edits are disabled, so the empty table shell is dropped.
+    expect(container.querySelector("table.library-admin-roles")).toBeNull();
+  });
+
+  it("still allows sitewide roles for a new admin when the library list failed", () => {
+    // A new admin has no hidden per-library roles to clobber.
+    const { container } = renderForm({ data: failureData });
+    expect(
+      screen.getByText(/Sitewide roles can still be assigned/)
+    ).toBeInTheDocument();
+    expect(roleCheckbox("system")).toBeEnabled();
+    expect(roleCheckbox("manager-all")).toBeEnabled();
+    // No misleading "no libraries" row under a failure.
+    expect(container.querySelector("tbody")).toBeEmptyDOMElement();
+  });
+
+  const staleData = {
+    individualAdmins: [adminData],
+    allLibraries,
+    allLibrariesRefreshError: {
+      status: 500,
+      response: "nope",
+      url: "/admin/libraries",
+    },
+  };
+
+  it("locks only per-library roles for an existing admin while the list is stale", () => {
+    const { container } = renderForm({ item: adminData, data: staleData });
+    expect(container.querySelector(".alert-warning")).toHaveTextContent(
+      "Per-library roles cannot be changed until the list can be refreshed."
+    );
+    // The role="alert" warning announces the refresh failure itself, so
+    // the status region empties rather than duplicating the announcement.
+    expect(container.querySelector('[role="status"]')).toBeEmptyDOMElement();
+    // Only the per-library un-check branches expand sitewide roles from
+    // the (stale) list; sitewide toggles are list-independent and stay
+    // assignable, so submitting cannot be forced into a roleless admin.
+    expect(roleCheckbox("system")).toBeEnabled();
+    expect(roleCheckbox("manager-all")).toBeEnabled();
+    expect(roleCheckbox("manager-nypl")).toBeDisabled();
+    expect(roleCheckbox("librarian-nypl")).toBeDisabled();
+  });
+
+  it("locks only per-library roles for a new admin while the list is stale", () => {
+    const { container } = renderForm({ data: staleData });
+    expect(container.querySelector(".alert-warning")).toHaveTextContent(
+      "Per-library roles cannot be changed"
+    );
+    expect(roleCheckbox("system")).toBeEnabled();
+    expect(roleCheckbox("manager-all")).toBeEnabled();
+    expect(roleCheckbox("manager-nypl")).toBeDisabled();
+  });
+
+  it("says when no libraries are configured", () => {
+    renderForm({
+      data: { individualAdmins: [adminData], allLibraries: [] },
+    });
+    expect(
+      screen.getByText("No libraries are configured.")
+    ).toBeInTheDocument();
+  });
+
   const expectRoles = (expected: string[]) => {
     for (const role of allRoles) {
       if (expected.includes(role)) {

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

@@ -46,6 +46,84 @@ describe("IndividualAdmins - role association disclosure", () => {
 
   // ── Toggle visibility ─────────────────────────────────────────────────────
 
+  it("shows no toggle while allLibraries has not settled", () => {
+    // Labels must render once, in final linked form, not flash bare short
+    // names that get rewritten when the sitewide list arrives.
+    const { container } = renderWithContext(
+      <IndividualAdmins
+        data={{
+          individualAdmins: [
+            {
+              email: "admin@example.org",
+              roles: [{ role: "manager", library: "alpha" }],
+            },
+          ],
+        }}
+        fetchData={jest.fn()}
+        editItem={jest.fn().mockResolvedValue(undefined)}
+        deleteItem={jest.fn().mockResolvedValue(undefined)}
+        csrfToken="token"
+        isFetching={false}
+      />,
+      sysAdminConfig
+    );
+    expect(container.querySelector(".association-toggle")).toBeNull();
+  });
+
+  it("shows the sysadmin entry before allLibraries settles", () => {
+    // The synthetic sysadmin entry never consults the library list and can
+    // never be rewritten by it, so it is not held back.
+    const { container } = renderWithContext(
+      <IndividualAdmins
+        data={{
+          individualAdmins: [
+            { email: "root@example.org", roles: [{ role: "system" }] },
+          ],
+        }}
+        fetchData={jest.fn()}
+        editItem={jest.fn().mockResolvedValue(undefined)}
+        deleteItem={jest.fn().mockResolvedValue(undefined)}
+        csrfToken="token"
+        isFetching={false}
+      />,
+      sysAdminConfig
+    );
+    fireEvent.click(container.querySelector(".association-toggle"));
+    expect(container.querySelector(".associated-items li").textContent).toBe(
+      "sysadmin"
+    );
+  });
+
+  it("names roles, not libraries, when the library list failed to load", () => {
+    const { container } = renderWithContext(
+      <IndividualAdmins
+        data={{
+          individualAdmins: [
+            {
+              email: "admin@example.org",
+              roles: [{ role: "manager", library: "alpha" }],
+            },
+          ],
+          allLibraries: [],
+          allLibrariesError: {
+            status: 500,
+            response: "nope",
+            url: "/admin/libraries",
+          },
+        }}
+        fetchData={jest.fn()}
+        editItem={jest.fn().mockResolvedValue(undefined)}
+        deleteItem={jest.fn().mockResolvedValue(undefined)}
+        csrfToken="token"
+        isFetching={false}
+      />,
+      sysAdminConfig
+    );
+    expect(container.querySelector(".alert-danger")).toHaveTextContent(
+      "Roles are shown by library short name only."
+    );
+  });
+
   it("shows no toggle for an admin with no roles field", () => {
     const { container } = renderAdmins([{ email: "noroles@example.com" }]);
     expect(container.querySelector(".association-toggle")).toBeNull();
@@ -498,10 +576,13 @@ describe("IndividualAdmins - connect wiring", () => {
   afterEach(() => jest.restoreAllMocks());
 
   it("renders the connected default export, fetching on mount", async () => {
-    jest.spyOn(globalThis, "fetch").mockResolvedValue(
-      new Response(JSON.stringify({ individualAdmins: [] }), {
-        headers: { "Content-Type": "application/json" },
-      })
+    // A Response body can only be read once, so build one per fetch call.
+    const fetchSpy = jest.spyOn(globalThis, "fetch").mockImplementation(() =>
+      Promise.resolve(
+        new Response(JSON.stringify({ individualAdmins: [] }), {
+          headers: { "Content-Type": "application/json" },
+        })
+      )
     );
 
     renderWithProviders(
@@ -517,5 +598,12 @@ describe("IndividualAdmins - connect wiring", () => {
     expect(
       await screen.findByText("Create new individual admin")
     ).toBeInTheDocument();
+
+    // Outside setup mode, fetchData also requests the libraries list (the
+    // settingUp half of that guard is pinned in SetupPage.test.tsx).
+    const urls = fetchSpy.mock.calls.map((call) => String(call[0]));
+    expect(urls).toEqual(
+      expect.arrayContaining([expect.stringContaining("/admin/libraries")])
+    );
   });
 });

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

@@ -87,6 +87,24 @@ describe("LibraryRegistration", () => {
       expect(libraries(container)).toHaveLength(0);
     });
 
+    it("explains instead of vanishing when the library list failed to load", () => {
+      const { container } = renderReg({
+        item: serviceData,
+        data: makeData({
+          allLibraries: [],
+          allLibrariesError: {
+            status: 500,
+            response: "nope",
+            url: "/admin/libraries",
+          },
+        }),
+      });
+      expect(libraries(container)).toHaveLength(0);
+      expect(container.querySelector(".alert-warning")).toHaveTextContent(
+        "Libraries cannot be registered: the library list is unavailable."
+      );
+    });
+
     it("doesn't render libraries in edit form if protocol doesn't support registration", () => {
       const { container } = renderReg({
         item: serviceData,

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

@@ -1,5 +1,5 @@
 import * as React from "react";
-import { render, screen, waitFor } from "@testing-library/react";
+import { render, screen, waitFor, within } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import * as fetchMock from "fetch-mock-jest";
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
@@ -217,8 +217,11 @@ describe("PatronAuthServiceEditForm – serialization", () => {
 
     await user.click(saveButton);
 
-    // The library should now be collapsed (indicating editLibrary was called)
+    // Saving collapses the library. Reopening it shows the rule was stored in
+    // library state, not just read from the editor.
     expect(screen.queryByRole("button", { name: /Add Rule/i })).toBeNull();
+    await user.click(screen.getByRole("button", { name: /Edit/i }));
+    expect(screen.getByLabelText(/Rule Name/i)).toHaveValue("Test Rule");
   });
 
   it("includes patron_blocking_rules in payload when adding a new library", async () => {
@@ -253,8 +256,99 @@ describe("PatronAuthServiceEditForm – serialization", () => {
 
     await user.click(addButton);
 
-    // After adding, the library should appear in the list, editor no longer in "new library" form
+    // The new-library editor is gone. Opening the added library shows the rule
+    // was stored in library state.
     expect(screen.queryByLabelText(/Rule Name/i)).toBeNull();
+    await user.click(screen.getByRole("button", { name: /Edit/i }));
+    expect(screen.getByLabelText(/Rule Name/i)).toHaveValue("New Rule");
+  });
+});
+
+describe("PatronAuthServiceEditForm – per-library settings", () => {
+  const LIB_SETTING_KEY = "lib_setting";
+  const protocolWithLibrarySettings = {
+    ...SIP2_PROTOCOL_DATA,
+    library_settings: [{ key: LIB_SETTING_KEY, label: "Library setting" }],
+  };
+  const dataWithLibrarySettings: PatronAuthServicesData = {
+    ...servicesData,
+    protocols: [protocolWithLibrarySettings, OTHER_PROTOCOL_DATA],
+  };
+  const settingInput = (root: HTMLElement) =>
+    within(root).getByRole("textbox", {
+      name: /Library setting/i,
+    }) as HTMLInputElement;
+
+  it("keeps a library setting entered when adding a new library", async () => {
+    const user = userEvent.setup();
+    const item = {
+      id: 3,
+      protocol: SIP2_PROTOCOL,
+      settings: {},
+      libraries: [],
+    };
+    const { container } = renderForm(
+      <PatronAuthServiceEditForm
+        {...baseProps}
+        data={dataWithLibrarySettings}
+        item={item}
+      />
+    );
+
+    await expandLibrariesPanel(user);
+    await user.selectOptions(
+      screen.getByRole("combobox", { name: /Add Library/i }),
+      LIBRARY_SHORT_NAME
+    );
+    await user.type(settingInput(container), "added value");
+    await user.click(screen.getByRole("button", { name: /Add Library/i }));
+
+    // Reopen the new library's settings; the value entered on add is there.
+    await user.click(screen.getByRole("button", { name: /Edit/i }));
+    const editSection = container.querySelector(
+      ".edit-library-settings"
+    ) as HTMLElement;
+    expect(settingInput(editSection).value).toBe("added value");
+  });
+
+  it("keeps a library setting changed when editing an existing library", async () => {
+    const user = userEvent.setup();
+    const item = {
+      ...buildSIP2Item(),
+      libraries: [
+        { short_name: LIBRARY_SHORT_NAME, [LIB_SETTING_KEY]: "old value" },
+      ],
+    };
+    const { container } = renderForm(
+      <PatronAuthServiceEditForm
+        {...baseProps}
+        data={dataWithLibrarySettings}
+        item={item}
+      />
+    );
+
+    await expandLibrariesPanel(user);
+    const clickEdit = () =>
+      user.click(screen.getByRole("button", { name: /Edit/i }));
+    await clickEdit();
+    let editSection = container.querySelector(
+      ".edit-library-settings"
+    ) as HTMLElement;
+    expect(settingInput(editSection).value).toBe("old value");
+
+    await user.clear(settingInput(editSection));
+    await user.type(settingInput(editSection), "new value");
+    await user.click(
+      editSection.querySelector("button.edit-library") as HTMLElement
+    );
+
+    // Saving collapses the library; reopening shows the saved value.
+    expect(container.querySelector(".edit-library-settings")).toBeNull();
+    await clickEdit();
+    editSection = container.querySelector(
+      ".edit-library-settings"
+    ) as HTMLElement;
+    expect(settingInput(editSection).value).toBe("new value");
   });
 });
 

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

@@ -77,6 +77,21 @@ describe("PatronAuthServices", () => {
     ).not.toBeInTheDocument();
   });
 
+  it("fetches the libraries list along with the services on mount", async () => {
+    const fetchSpy = stubFetch(listData);
+    renderConnected(<PatronAuthServices csrfToken="token" />);
+
+    await waitFor(() => {
+      const urls = fetchSpy.mock.calls.map((call) => String(call[0]));
+      expect(urls).toEqual(
+        expect.arrayContaining([
+          expect.stringContaining("/admin/patron_auth_services"),
+          expect.stringContaining("/admin/libraries"),
+        ])
+      );
+    });
+  });
+
   it("shows the neighborhood analytics panel when creating a service whose protocol has a neighborhood_mode setting", async () => {
     const neighborhoodSetting = {
       key: "neighborhood_mode",