@thepalaceproject/circulation-admin 1.43.0-post.1 → 1.43.0-post.11

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

@@ -0,0 +1,73 @@
+import * as React from "react";
+import { screen } from "@testing-library/react";
+
+import { renderWithProviders } from "../testUtils/withProviders";
+
+// Header and Footer are page chrome; Header pulls in the react-router v3 context
+// that renderWithProviders does not supply. Mock them to markers.
+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 ManagePatrons from "../../../src/components/ManagePatrons";
+
+describe("ManagePatrons", () => {
+  it("shows Header", () => {
+    renderWithProviders(<ManagePatrons params={{ library: "", tab: "" }} />);
+
+    expect(screen.getByTestId("header")).toBeInTheDocument();
+  });
+
+  it("should have a .manage-patrons-page class", () => {
+    const { container } = renderWithProviders(
+      <ManagePatrons params={{ library: "", tab: "" }} />
+    );
+
+    expect(container.querySelector(".manage-patrons-page")).toBeInTheDocument();
+  });
+
+  it("shows heading", () => {
+    renderWithProviders(<ManagePatrons params={{ library: "", tab: "" }} />);
+
+    expect(
+      screen.getByRole("heading", { name: "Patron Manager" })
+    ).toBeInTheDocument();
+  });
+
+  it("shows ManagePatronsTabContainer", () => {
+    // A library manager for "NYPL" sees a tab per patron action, which proves
+    // both the library and tab props reached the tab container.
+    const { container } = renderWithProviders(
+      <ManagePatrons params={{ library: "NYPL", tab: "resetAdobeId" }} />,
+      { appConfigSettings: { roles: [{ role: "manager", library: "NYPL" }] } }
+    );
+
+    const tabContainer = container.querySelector(".tab-container");
+    expect(tabContainer).toBeInTheDocument();
+
+    // The tab <li>s carry role="presentation", so query them directly.
+    const tabs = (tabContainer as HTMLElement).querySelectorAll(
+      "ul.nav-tabs > li"
+    );
+    expect(tabs).toHaveLength(2);
+    expect(
+      screen.getByRole("link", { name: "Reset Adobe ID" })
+    ).toBeInTheDocument();
+    expect(
+      screen.getByRole("link", { name: "Debug Authentication" })
+    ).toBeInTheDocument();
+    // The `tab` prop selects the active tab.
+    expect(tabs[0]).toHaveClass("active");
+  });
+
+  it("shows Footer", () => {
+    renderWithProviders(<ManagePatrons params={{ library: "", tab: "" }} />);
+
+    expect(screen.getByTestId("footer")).toBeInTheDocument();
+  });
+});

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

@@ -0,0 +1,180 @@
+import * as React from "react";
+import { screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+
+import { renderWithProviders } from "../testUtils/withProviders";
+import { installFormDataShim } from "../testUtils/formDataShim";
+import buildStore from "../../../src/store";
+import { ManagePatronsForm } from "../../../src/components/ManagePatronsForm";
+import { PatronData } from "../../../src/interfaces";
+
+// The reusable-components `Form` builds `new FormData(formElement)` on submit,
+// which the unit jsdom environment's undici FormData rejects; install the shared
+// shim that reads the form's successful controls.
+installFormDataShim();
+
+const patron: PatronData = {
+  authorization_expires: "",
+  username: "User Name",
+  personal_name: "Personal Name",
+  email_address: "user@email.com",
+  authorization_identifier: "1234",
+  authorization_identifiers: [""],
+  block_reason: "",
+  external_type: "",
+  fines: "",
+  permanent_id: "",
+};
+
+// `clearPatronData` is called on unmount (RTL cleanup), so it must always be a
+// function; `patronLookup` too, so the connected dispatch props are stubbed.
+const renderForm = (props: Record<string, unknown> = {}) =>
+  renderWithProviders(
+    <ManagePatronsForm
+      store={buildStore()}
+      csrfToken="token"
+      library="nypl"
+      patronLookup={jest.fn()}
+      clearPatronData={jest.fn()}
+      {...props}
+    />
+  );
+
+describe("ManagePatronsForm", () => {
+  describe("rendering", () => {
+    it("has .manage-patrons-form class", () => {
+      const { container } = renderForm();
+      expect(
+        container.querySelector(".manage-patrons-form")
+      ).toBeInTheDocument();
+    });
+
+    it("shows an editable identifier input", () => {
+      renderForm();
+      expect(
+        screen.getByPlaceholderText("Enter the patron's identifier")
+      ).toBeInTheDocument();
+      expect(screen.getByRole("textbox")).toBeInTheDocument();
+    });
+
+    it("has a form with an input field and a button", () => {
+      const { container } = renderForm();
+      expect(container.querySelectorAll("form")).toHaveLength(1);
+      expect(container.querySelectorAll("form input")).toHaveLength(1);
+      expect(container.querySelectorAll("form button")).toHaveLength(1);
+    });
+
+    it("doesn't initially show an alert or error message", () => {
+      const { container } = renderForm();
+      expect(container.querySelector(".alert")).not.toBeInTheDocument();
+      expect(screen.queryByText(/Patron found/)).not.toBeInTheDocument();
+    });
+  });
+
+  describe("behavior", () => {
+    it("calls patronLookup on submit", async () => {
+      const user = userEvent.setup();
+      const patronLookup = jest.fn();
+      renderForm({ patronLookup });
+
+      expect(patronLookup).not.toHaveBeenCalled();
+
+      await user.type(
+        screen.getByPlaceholderText("Enter the patron's identifier"),
+        "1234"
+      );
+      await user.click(screen.getByRole("button"));
+
+      expect(patronLookup).toHaveBeenCalledTimes(1);
+      // The second argument is the library short name.
+      expect(patronLookup.mock.calls[0][1]).toBe("nypl");
+    });
+
+    it("displays an error message if there is an error", () => {
+      const fetchError = { status: 400, response: "", url: "" };
+      const { container, rerender } = renderForm();
+      expect(container.querySelector(".alert-danger")).not.toBeInTheDocument();
+
+      rerender(
+        <ManagePatronsForm
+          store={buildStore()}
+          csrfToken="token"
+          library="nypl"
+          patronLookup={jest.fn()}
+          clearPatronData={jest.fn()}
+          fetchError={fetchError}
+        />
+      );
+
+      expect(container.querySelector(".alert-danger")).toBeInTheDocument();
+      expect(screen.getByText(/Error:/)).toBeInTheDocument();
+    });
+
+    it("should display a no-identifier message if the input field is blank when searching", () => {
+      const fetchError = {
+        status: 400,
+        response: "No patron identifier provided",
+        url: "",
+      };
+      const { rerender } = renderForm();
+      expect(
+        screen.queryByText("Error: No patron identifier provided")
+      ).not.toBeInTheDocument();
+
+      rerender(
+        <ManagePatronsForm
+          store={buildStore()}
+          csrfToken="token"
+          library="nypl"
+          patronLookup={jest.fn()}
+          clearPatronData={jest.fn()}
+          fetchError={fetchError}
+        />
+      );
+
+      expect(
+        screen.getByText("Error: No patron identifier provided")
+      ).toBeInTheDocument();
+    });
+
+    it("should display a success alert message when a patron is found", () => {
+      const { container, rerender } = renderForm();
+      expect(container.querySelector(".alert-success")).not.toBeInTheDocument();
+
+      rerender(
+        <ManagePatronsForm
+          store={buildStore()}
+          csrfToken="token"
+          library="nypl"
+          patronLookup={jest.fn()}
+          clearPatronData={jest.fn()}
+          patron={patron}
+        />
+      );
+
+      const alert = container.querySelector(".alert-success");
+      expect(alert).toBeInTheDocument();
+      expect(alert).toHaveTextContent(
+        `Patron found: ${patron.authorization_identifier}`
+      );
+    });
+
+    it("should show the PatronInfo list when a patron is found", () => {
+      const { container, rerender } = renderForm();
+      expect(container.querySelector(".patron-info")).not.toBeInTheDocument();
+
+      rerender(
+        <ManagePatronsForm
+          store={buildStore()}
+          csrfToken="token"
+          library="nypl"
+          patronLookup={jest.fn()}
+          clearPatronData={jest.fn()}
+          patron={patron}
+        />
+      );
+
+      expect(container.querySelector(".patron-info")).toBeInTheDocument();
+    });
+  });
+});

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

@@ -0,0 +1,143 @@
+import * as React from "react";
+import * as PropTypes from "prop-types";
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+
+import buildStore from "../../../src/store";
+import Admin from "../../../src/models/Admin";
+
+// Both tab panels fetch on mount (ResetAdobeId is a connected component; Debug
+// Authentication uses react-query). They're incidental to a tab-navigation test,
+// so mock them to markers. ResetAdobeId echoes the csrfToken asserted below.
+jest.mock("../../../src/components/ResetAdobeId", () => ({
+  __esModule: true,
+  default: (props: any) => (
+    <div data-testid="reset-adobe-id" data-csrf-token={props.csrfToken} />
+  ),
+}));
+jest.mock("../../../src/components/DebugAuthentication", () => ({
+  __esModule: true,
+  default: () => <div data-testid="debug-authentication" />,
+}));
+
+import ManagePatronsTabContainer from "../../../src/components/ManagePatronsTabContainer";
+
+// ManagePatronsTabContainer reads `admin`, `router`, and `pathFor` from the legacy
+// React context the app supplies in production. Wrap it in a small provider that
+// hands it those.
+class LegacyContextProvider extends React.Component<{ context: any }> {
+  static childContextTypes = {
+    router: PropTypes.object,
+    pathFor: PropTypes.func,
+    admin: PropTypes.object,
+  };
+  getChildContext() {
+    return this.props.context;
+  }
+  render() {
+    return this.props.children;
+  }
+}
+
+describe("ManagePatronsTabContainer", () => {
+  const systemAdmin = new Admin([{ role: "system" }]);
+  const libraryManagerNYPL = new Admin([{ role: "manager", library: "NYPL" }]);
+  const libraryManagerA = new Admin([{ role: "manager", library: "a" }]);
+  const librarian = new Admin([{ role: "librarian", library: "NYPL" }]);
+
+  const renderWithAdmin = (admin: Admin, push: jest.Mock = jest.fn()) => {
+    const context = { router: { push }, pathFor: jest.fn(), admin };
+    const result = render(
+      <LegacyContextProvider context={context}>
+        <ManagePatronsTabContainer
+          tab={null}
+          csrfToken="token"
+          store={buildStore()}
+          library="NYPL"
+        />
+      </LegacyContextProvider>
+    );
+    return { ...result, push };
+  };
+
+  describe("for system admin", () => {
+    it("shows tabs", () => {
+      renderWithAdmin(systemAdmin);
+      expect(
+        screen.getByRole("link", { name: "Reset Adobe ID" })
+      ).toBeInTheDocument();
+      expect(
+        screen.getByRole("link", { name: "Debug Authentication" })
+      ).toBeInTheDocument();
+    });
+
+    it("shows components", () => {
+      renderWithAdmin(systemAdmin);
+      expect(screen.getByTestId("reset-adobe-id")).toHaveAttribute(
+        "data-csrf-token",
+        "token"
+      );
+    });
+
+    it("uses router to navigate when tab is clicked", async () => {
+      const user = userEvent.setup();
+      const { push } = renderWithAdmin(systemAdmin);
+      await user.click(screen.getByRole("link", { name: "Reset Adobe ID" }));
+      expect(push).toHaveBeenCalledTimes(1);
+      expect(push).toHaveBeenCalledWith("/admin/web/patrons/NYPL/resetAdobeId");
+    });
+  });
+
+  describe("for right library manager", () => {
+    it("shows tabs", () => {
+      renderWithAdmin(libraryManagerNYPL);
+      expect(
+        screen.getByRole("link", { name: "Reset Adobe ID" })
+      ).toBeInTheDocument();
+      expect(
+        screen.getByRole("link", { name: "Debug Authentication" })
+      ).toBeInTheDocument();
+    });
+
+    it("marks the current tab as active", () => {
+      const { container } = renderWithAdmin(libraryManagerNYPL);
+      const tabItems = container.querySelectorAll("ul.nav-tabs li");
+      expect(tabItems).toHaveLength(2);
+      expect(tabItems[0]).toHaveClass("active");
+    });
+
+    it("shows components", () => {
+      renderWithAdmin(libraryManagerNYPL);
+      expect(screen.getByTestId("reset-adobe-id")).toHaveAttribute(
+        "data-csrf-token",
+        "token"
+      );
+    });
+
+    it("uses router to navigate when tab is clicked", async () => {
+      const user = userEvent.setup();
+      const { push } = renderWithAdmin(libraryManagerNYPL);
+      await user.click(screen.getByRole("link", { name: "Reset Adobe ID" }));
+      expect(push).toHaveBeenCalledTimes(1);
+      expect(push).toHaveBeenCalledWith("/admin/web/patrons/NYPL/resetAdobeId");
+    });
+  });
+
+  describe("for wrong library manager", () => {
+    it("doesn't show tabs", () => {
+      renderWithAdmin(libraryManagerA);
+      expect(
+        screen.queryByRole("link", { name: "Reset Adobe ID" })
+      ).not.toBeInTheDocument();
+    });
+  });
+
+  describe("for librarian", () => {
+    it("doesn't show tabs", () => {
+      renderWithAdmin(librarian);
+      expect(
+        screen.queryByRole("link", { name: "Reset Adobe ID" })
+      ).not.toBeInTheDocument();
+    });
+  });
+});

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

@@ -0,0 +1,59 @@
+import * as React from "react";
+import { screen, within } from "@testing-library/react";
+import { MetadataServices } from "../../../src/components/MetadataServices";
+import renderWithContext from "../testUtils/renderWithContext";
+import { defaultFeatureFlags } from "../../../src/utils/featureFlags";
+
+describe("MetadataServices", () => {
+  const data = {
+    metadata_services: [
+      {
+        id: 2,
+        protocol: "test protocol",
+        name: "sample name",
+        settings: {
+          test_setting: "test setting",
+        },
+        libraries: [{ short_name: "nypl" }],
+      },
+    ],
+    protocols: [
+      {
+        name: "test protocol",
+        label: "test protocol label",
+        sitewide: false,
+        settings: [],
+      },
+    ],
+    allLibraries: [
+      {
+        short_name: "nypl",
+      },
+    ],
+  };
+
+  const config = { csrfToken: "token", featureFlags: defaultFeatureFlags };
+
+  it("shows metadata service list", () => {
+    renderWithContext(
+      <MetadataServices
+        data={data}
+        fetchData={jest.fn()}
+        editItem={jest.fn().mockResolvedValue(undefined)}
+        csrfToken="token"
+        isFetching={false}
+      />,
+      config
+    );
+
+    const items = screen.getAllByRole("listitem");
+    expect(items).toHaveLength(1);
+    expect(items[0]).toHaveTextContent("sample name: test protocol");
+
+    const editLink = within(items[0]).getByRole("link");
+    expect(editLink).toHaveAttribute(
+      "href",
+      "/admin/web/config/metadata/edit/2"
+    );
+  });
+});

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

@@ -0,0 +1,114 @@
+import * as React from "react";
+import { screen, waitFor } from "@testing-library/react";
+
+import { renderWithProviders } from "../testUtils/withProviders";
+import buildStore from "../../../src/store";
+// Render the CONNECTED default export so that mapStateToProps / mapDispatchToProps
+// are exercised: the panel fetches its data on mount, the fetch populates the
+// Redux store, and mapStateToProps feeds it back in as props.
+import PatronAuthServices from "../../../src/components/PatronAuthServices";
+
+const listData = {
+  patron_auth_services: [
+    {
+      id: 2,
+      protocol: "test protocol",
+      settings: { test_setting: "test setting" },
+      libraries: [
+        { short_name: "nypl", test_library_setting: "test library setting" },
+      ],
+      name: "nypl protocol",
+    },
+  ],
+  protocols: [
+    { name: "test protocol", label: "test protocol label", settings: [] },
+  ],
+  allLibraries: [{ short_name: "nypl" }],
+};
+
+/**
+ * Stub `fetch` so the panel's on-mount fetch resolves with `body`. Returning a
+ * fresh Response per call avoids "body already used" when several fetches run.
+ */
+const stubFetch = (body: unknown) =>
+  jest.spyOn(globalThis, "fetch").mockImplementation(
+    async () =>
+      new Response(JSON.stringify(body), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      })
+  );
+
+// A fresh store per test keeps the fetched data isolated between tests.
+const renderConnected = (element: React.ReactElement) =>
+  renderWithProviders(element, {
+    reduxProviderProps: { store: buildStore() },
+  });
+
+describe("PatronAuthServices", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it("shows the patron auth service list", async () => {
+    stubFetch(listData);
+    const { container } = renderConnected(
+      <PatronAuthServices csrfToken="token" />
+    );
+
+    // The list appears once the connected component's on-mount fetch resolves.
+    // Its heading is the protocol-aware label built by PatronAuthServices.label().
+    expect(
+      await screen.findByRole("heading", {
+        level: 3,
+        name: /nypl protocol: test protocol label/,
+      })
+    ).toBeInTheDocument();
+
+    const editLink = container.querySelector("a.edit-item");
+    expect(editLink).not.toBeNull();
+    expect(editLink.getAttribute("href")).toBe(
+      "/admin/web/config/patronAuth/edit/2"
+    );
+
+    // No neighborhood analytics panel is shown in list mode.
+    expect(
+      screen.queryByText("Patron Neighborhood Analytics: Disabled")
+    ).not.toBeInTheDocument();
+  });
+
+  it("shows the neighborhood analytics panel when creating a service whose protocol has a neighborhood_mode setting", async () => {
+    const neighborhoodSetting = {
+      key: "neighborhood_mode",
+      label: "Neighborhood Mode",
+      description: "",
+      options: [],
+    };
+    const createData = {
+      patron_auth_services: [],
+      protocols: [
+        {
+          name: "test protocol",
+          label: "test protocol label",
+          settings: [neighborhoodSetting],
+        },
+      ],
+      allLibraries: [{ short_name: "nypl" }],
+    };
+    stubFetch(createData);
+
+    const { container } = renderConnected(
+      <PatronAuthServices csrfToken="token" editOrCreate="create" />
+    );
+
+    // Once the protocol data loads, the create form's extra section (the
+    // NeighborhoodAnalyticsForm) renders because the selected protocol carries a
+    // "neighborhood_mode" setting.
+    await waitFor(() =>
+      expect(container.querySelector("#neighborhood-panel")).toBeInTheDocument()
+    );
+    expect(
+      screen.getByText("Patron Neighborhood Analytics: Disabled")
+    ).toBeInTheDocument();
+  });
+});

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

@@ -612,7 +612,9 @@ describe("PatronBlockingRulesEditor", () => {
   });
 
   it("disables all editing inputs and buttons when disabled prop is true", () => {
-    renderEditor(<PatronBlockingRulesEditor value={existingRules} disabled={true} />);
+    renderEditor(
+      <PatronBlockingRulesEditor value={existingRules} disabled={true} />
+    );
 
     // The Help button stays enabled even in disabled mode (read-only affordance).
     const editingButtons = screen

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

@@ -0,0 +1,54 @@
+import * as React from "react";
+import { render } from "@testing-library/react";
+
+import PatronInfo from "../../../src/components/PatronInfo";
+import { PatronData } from "../../../src/interfaces";
+
+const patrons: PatronData[] = [
+  {
+    authorization_expires: "",
+    username: "User Name",
+    personal_name: "Personal Name",
+    email_address: "user@email.com",
+    authorization_identifier: "1234",
+    authorization_identifiers: [""],
+    block_reason: "",
+    external_type: "",
+    fines: "",
+    permanent_id: "",
+  },
+  {
+    authorization_expires: "",
+    personal_name: "Personal Name2",
+    authorization_identifier: "5678",
+    authorization_identifiers: [""],
+    block_reason: "",
+    external_type: "",
+    fines: "",
+    permanent_id: "",
+  },
+];
+
+describe("PatronInfo", () => {
+  it("should display the patron's information", () => {
+    const { container } = render(<PatronInfo patron={patrons[0]} />);
+
+    const items = container.querySelectorAll("ul.patron-data-list > li");
+    expect(items).toHaveLength(4);
+    expect(items[0]).toHaveTextContent("Username:User Name");
+    expect(items[1]).toHaveTextContent("Personal Name:Personal Name");
+    expect(items[2]).toHaveTextContent("Email Address:user@email.com");
+    expect(items[3]).toHaveTextContent("Identifier:1234");
+  });
+
+  it("should update the patron's information if a new patron was searched and found", () => {
+    const { container, rerender } = render(<PatronInfo patron={patrons[0]} />);
+
+    rerender(<PatronInfo patron={patrons[1]} />);
+
+    const items = container.querySelectorAll("ul.patron-data-list > li");
+    expect(items).toHaveLength(2);
+    expect(items[0]).toHaveTextContent("Personal Name:Personal Name2");
+    expect(items[1]).toHaveTextContent("Identifier:5678");
+  });
+});