@thepalaceproject/circulation-admin 1.46.0-post.1 → 1.46.0-post.3

package/package.json

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

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,11 @@ 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");
   });
 });
 
@@ -268,8 +274,10 @@ describe("PatronAuthServiceEditForm – per-library settings", () => {
     ...servicesData,
     protocols: [protocolWithLibrarySettings, OTHER_PROTOCOL_DATA],
   };
-  const settingInput = (root: ParentNode) =>
-    root.querySelector(`input[name="${LIB_SETTING_KEY}"]`) as HTMLInputElement;
+  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();

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",

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

@@ -4,6 +4,7 @@ import { render, within } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 
 import ServiceEditForm, {
+  libraryRefKey,
   ServiceEditFormProps,
   ServiceEditFormState,
 } from "../../../src/components/ServiceEditForm";
@@ -483,6 +484,91 @@ describe("ServiceEditForm", () => {
       expect(container.querySelector(".with-edit-button a")).toBeNull();
     });
 
+    it("shows a loading indicator in the Libraries panel until allLibraries arrives", () => {
+      // Undefined allLibraries means the library list is still loading.
+      const dataStillLoading = Object.assign({}, servicesData, {
+        allLibraries: undefined,
+      });
+      const { container, rerender } = renderForm({
+        data: dataStillLoading,
+        item: serviceData,
+      });
+      expect(container.querySelector(".update-libraries")).toBeNull();
+      expect(container.querySelector('[role="status"]')).toHaveTextContent(
+        "Loading libraries..."
+      );
+
+      rerenderForm(rerender, { item: serviceData });
+      // The status line stays mounted and announces completion; the
+      // completion text is visually hidden.
+      const status = container.querySelector('[role="status"]');
+      expect(status).toHaveTextContent("Libraries loaded.");
+      expect(status).toHaveClass("visuallyHidden");
+      const editable = container.querySelectorAll(".with-edit-button");
+      expect(editable).toHaveLength(1);
+      expect(editable[0]).toHaveTextContent("New York Public Library - nypl");
+    });
+
+    it("explains a failed library list load in the Libraries panel", () => {
+      // On failure allLibraries settles to [] and allLibrariesError is set.
+      const dataWithError = Object.assign({}, servicesData, {
+        allLibraries: [],
+        allLibrariesError: {
+          status: 500,
+          response: "nope",
+          url: "/admin/libraries",
+        },
+      });
+      const { container } = renderForm({
+        data: dataWithError,
+        item: serviceData,
+      });
+      expect(container.querySelector(".alert-danger")).toHaveTextContent(
+        "The library list failed to load"
+      );
+      // 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();
+      // The associated library still renders, by short name.
+      const editable = container.querySelectorAll(".with-edit-button");
+      expect(editable).toHaveLength(1);
+      expect(editable[0]).toHaveTextContent("nypl");
+      // A removal could not be undone in-session, so it is disabled too.
+      expect(container.querySelector("button.remove-btn")).toBeDisabled();
+    });
+
+    it("warns when the library list could not be refreshed", () => {
+      const staleData = Object.assign({}, servicesData, {
+        allLibrariesRefreshError: {
+          status: 500,
+          response: "nope",
+          url: "/admin/libraries",
+        },
+      });
+      const { container } = renderForm({ data: staleData, item: serviceData });
+      expect(container.querySelector(".alert-warning")).toHaveTextContent(
+        "The library list could not 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();
+      // The stale list still renders in full, links included, and the
+      // panel stays editable; only the blocking error disables removal.
+      const editable = container.querySelectorAll(".with-edit-button");
+      expect(editable).toHaveLength(1);
+      expect(editable[0]).toHaveTextContent("New York Public Library - nypl");
+      expect(container.querySelector(".alert-danger")).toBeNull();
+      expect(container.querySelector("button.remove-btn")).toBeEnabled();
+    });
+
+    it("says when no libraries are configured", () => {
+      const emptyData = Object.assign({}, servicesData, { allLibraries: [] });
+      const { container } = renderForm({ data: emptyData });
+      expect(container.querySelector(".update-libraries")).toHaveTextContent(
+        "No libraries are configured."
+      );
+    });
+
     it("renders removable and editable libraries", () => {
       const { container, unmount } = renderForm();
       expect(container.querySelectorAll(".with-remove-button")).toHaveLength(0);
@@ -999,6 +1085,15 @@ describe("ServiceEditForm", () => {
       ).toBe("option3");
     });
 
+    it("builds library ref keys for add and edit mode", () => {
+      expect(libraryRefKey("key", "add")).toBe("key");
+      expect(libraryRefKey("key", "edit", "nypl")).toBe("nypl_key");
+      // Compile-time guard: ts-jest fails this file if the overloads stop
+      // rejecting an edit-mode call with no short name.
+      // @ts-expect-error edit mode must pass the library short name
+      libraryRefKey("key", "edit");
+    });
+
     it("calls save when the form is submitted", async () => {
       // The reusable Form wires submission solely through its submit button's
       // onClick, so clicking it is the only way to submit; assert the resulting

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

@@ -6,13 +6,16 @@ import SetupPage from "../../../src/components/SetupPage";
 
 describe("SetupPage", () => {
   beforeEach(() => {
-    // SetupPage renders the connected IndividualAdmins list, which fetches the
-    // admin list on mount. Stub fetch so mounting does not hit the network.
-    jest.spyOn(globalThis, "fetch").mockResolvedValue(
-      new Response(JSON.stringify({ individualAdmins: [] }), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      })
+    // SetupPage renders the connected IndividualAdmins list, which fetches on
+    // mount. Stub fetch so mounting does not hit the network; a Response body
+    // can only be read once, so build one per call.
+    jest.spyOn(globalThis, "fetch").mockImplementation(() =>
+      Promise.resolve(
+        new Response(JSON.stringify({ individualAdmins: [] }), {
+          status: 200,
+          headers: { "Content-Type": "application/json" },
+        })
+      )
     );
   });
 
@@ -37,5 +40,19 @@ describe("SetupPage", () => {
         name: "Set up your system admin account",
       })
     ).toBeInTheDocument();
+
+    // settingUp skips the libraries request, which cannot succeed before an
+    // admin exists. The positive check keeps the negative one honest.
+    const urls = (globalThis.fetch as jest.Mock).mock.calls.map((call) =>
+      String(call[0])
+    );
+    expect(urls).toEqual(
+      expect.arrayContaining([
+        expect.stringContaining("/admin/individual_admins"),
+      ])
+    );
+    expect(urls).not.toEqual(
+      expect.arrayContaining([expect.stringContaining("/admin/libraries")])
+    );
   });
 });