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

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

@@ -0,0 +1,203 @@
+import * as React from "react";
+import { installFormDataShim } from "../testUtils/formDataShim";
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+
+import LibraryRegistrationForm from "../../../src/components/LibraryRegistrationForm";
+installFormDataShim();
+
+describe("LibraryRegistrationForm", () => {
+  const library = {
+    name: "Test Library",
+    status: "success",
+    stage: "production",
+  };
+  const registrationData = {
+    id: 1,
+    libraries: [library],
+    access_problem: null,
+    terms_of_service_html:
+      "Here are the <a href='terms.html'>terms of service</a>!",
+    terms_of_service_link: "terms.html",
+  };
+
+  type Props = React.ComponentProps<typeof LibraryRegistrationForm>;
+
+  const makeProps = (overrides: Partial<Props> = {}): Props => ({
+    library: library as Props["library"],
+    checked: true,
+    buttonText: "Update registration",
+    register: jest.fn(),
+    disabled: false,
+    registrationData: registrationData as Props["registrationData"],
+    ...overrides,
+  });
+
+  const renderForm = (overrides: Partial<Props> = {}) => {
+    const props = makeProps(overrides);
+    const result = render(<LibraryRegistrationForm {...props} />);
+    const rerender = (nextOverrides: Partial<Props>) =>
+      result.rerender(
+        <LibraryRegistrationForm {...makeProps(nextOverrides)} />
+      );
+    return { ...result, rerender, props };
+  };
+
+  it("does not display a label and checkbox if there is no terms-of-service data", () => {
+    const { container } = renderForm({ registrationData: null });
+
+    expect(
+      container.querySelector(".registration-checkbox")
+    ).not.toBeInTheDocument();
+    expect(
+      screen.queryByText("I agree to the terms of service.")
+    ).not.toBeInTheDocument();
+    expect(screen.queryByRole("link")).not.toBeInTheDocument();
+    expect(screen.queryByRole("checkbox")).not.toBeInTheDocument();
+  });
+
+  it("displays an error message if there is a problem with the terms-of-service data", () => {
+    const dataWithProblem = {
+      ...registrationData,
+      access_problem: { detail: "Something went wrong." },
+    };
+    const { container } = renderForm({
+      registrationData: dataWithProblem as Props["registrationData"],
+    });
+
+    const danger = container.querySelector(".registration-checkbox .bg-danger");
+    expect(danger).toHaveTextContent("Something went wrong.");
+    // If the terms can't be displayed, there's no point showing the checkbox
+    // and button.
+    expect(screen.queryByRole("checkbox")).not.toBeInTheDocument();
+    expect(screen.queryByRole("button")).not.toBeInTheDocument();
+  });
+
+  it("displays content and a checkbox with a label if there is terms-of-service HTML", () => {
+    const { container } = renderForm();
+
+    const termsSection = container.querySelector(".registration-checkbox");
+    expect(termsSection).toBeInTheDocument();
+
+    const content = termsSection.querySelector("p");
+    expect(content).toHaveTextContent("Here are the terms of service!");
+
+    const checkbox = screen.getByRole("checkbox", {
+      name: "I agree to the terms of service.",
+    });
+    expect(checkbox).toBeInTheDocument();
+    expect(checkbox).toHaveAttribute("type", "checkbox");
+  });
+
+  it("displays content and a checkbox with a label if there is a terms-of-service link", () => {
+    const { container } = renderForm({
+      registrationData: {
+        ...registrationData,
+        terms_of_service_html: null,
+      } as Props["registrationData"],
+    });
+
+    const termsSection = container.querySelector(".registration-checkbox");
+    expect(termsSection).toBeInTheDocument();
+
+    const content = termsSection.querySelector("p");
+    expect(content).toHaveTextContent(
+      "You must read the terms of service before registering your library."
+    );
+
+    const link = screen.getByRole("link", { name: "terms of service" });
+    expect(link).toHaveAttribute("href", "terms.html");
+
+    const checkbox = screen.getByRole("checkbox", {
+      name: "I agree to the terms of service.",
+    });
+    expect(checkbox).toBeInTheDocument();
+    expect(checkbox).toHaveAttribute("type", "checkbox");
+  });
+
+  it("displays a registration button", () => {
+    const { rerender } = renderForm();
+    expect(
+      screen.getByRole("button", { name: "Update registration" })
+    ).toBeInTheDocument();
+
+    rerender({ buttonText: "Register" });
+    expect(
+      screen.getByRole("button", { name: "Register" })
+    ).toBeInTheDocument();
+
+    rerender({ buttonText: "Retry registration" });
+    expect(
+      screen.getByRole("button", { name: "Retry registration" })
+    ).toBeInTheDocument();
+  });
+
+  it("disables the button if there is a checkbox and it is unchecked", async () => {
+    const user = userEvent.setup();
+    renderForm();
+
+    const button = screen.getByRole("button", { name: "Update registration" });
+    expect(button).toBeEnabled();
+
+    // Unchecking the terms-of-service checkbox disables the button.
+    await user.click(
+      screen.getByRole("checkbox", {
+        name: "I agree to the terms of service.",
+      })
+    );
+
+    expect(
+      screen.getByRole("button", { name: "Update registration" })
+    ).toBeDisabled();
+  });
+
+  it("disables the button if the disabled prop is set to true, regardless of the checkbox", () => {
+    const { rerender } = renderForm();
+
+    rerender({ disabled: true });
+    expect(
+      screen.getByRole("button", { name: "Update registration" })
+    ).toBeDisabled();
+
+    rerender({ disabled: false });
+    expect(
+      screen.getByRole("button", { name: "Update registration" })
+    ).toBeEnabled();
+  });
+
+  it("determines whether to pre-check the checkbox", () => {
+    const { rerender } = renderForm();
+
+    expect(
+      screen.getByRole("checkbox", {
+        name: "I agree to the terms of service.",
+      })
+    ).toBeChecked();
+
+    rerender({ checked: false });
+    expect(
+      screen.getByRole("checkbox", {
+        name: "I agree to the terms of service.",
+      })
+    ).not.toBeChecked();
+  });
+
+  it("calls register", async () => {
+    const user = userEvent.setup();
+    const register = jest.fn();
+    const { rerender } = renderForm({ register });
+
+    await user.click(
+      screen.getByRole("button", { name: "Update registration" })
+    );
+    expect(register).toHaveBeenCalledTimes(1);
+    expect(register).toHaveBeenCalledWith(library);
+
+    // A disabled button does not fire register again.
+    rerender({ register, disabled: true });
+    await user.click(
+      screen.getByRole("button", { name: "Update registration" })
+    );
+    expect(register).toHaveBeenCalledTimes(1);
+  });
+});

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/ResetAdobeId.test.tsx

@@ -0,0 +1,302 @@
+import * as React from "react";
+import { screen, waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+
+import buildStore from "../../../src/store";
+import { renderWithProviders } from "../testUtils/withProviders";
+import ConnectedResetAdobeId, {
+  ResetAdobeId,
+} from "../../../src/components/ResetAdobeId";
+
+const patrons = [
+  {
+    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("ResetAdobeId", () => {
+  let store: ReturnType<typeof buildStore>;
+
+  beforeEach(() => {
+    store = buildStore();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  // Render the unconnected component with explicit props (patron / resetAdobeId /
+  // responseBody / fetchError are what `connect` would otherwise source from the
+  // store, so tests inject them directly). Wrapped in providers because the
+  // ManagePatronsForm it renders is connected.
+  const resetElement = (props: Record<string, unknown> = {}) => (
+    <ResetAdobeId store={store} csrfToken="token" library="nypl" {...props} />
+  );
+  const renderReset = (props: Record<string, unknown> = {}) =>
+    renderWithProviders(resetElement(props));
+
+  describe("rendering without patron", () => {
+    it("has the patron-actions class", () => {
+      const { container } = renderReset({ patron: null });
+      expect(container.firstChild).toHaveClass("patron-actions");
+    });
+
+    it("has a header", () => {
+      renderReset({ patron: null });
+      expect(
+        screen.getByRole("heading", { name: "Reset Adobe ID" })
+      ).toBeInTheDocument();
+    });
+
+    it("does not render a patron-info section", () => {
+      const { container } = renderReset({ patron: null });
+      expect(container.querySelector(".patron-info")).not.toBeInTheDocument();
+    });
+
+    it("prompts the user to search for a patron", () => {
+      renderReset({ patron: null });
+      expect(
+        screen.getByText("Search for a patron to begin.")
+      ).toBeInTheDocument();
+    });
+  });
+
+  describe("rendering with patron", () => {
+    it("shows a warning before the submit button", () => {
+      const { container } = renderReset({ patron: patrons[0] });
+      expect(container.querySelector(".patron-warning")).toHaveTextContent(
+        "IMPORTANT: Patron User Name will lose access to any existing loans. Loans will still appear in the patron's book list until they expire, but the patron will be unable to read or return them."
+      );
+    });
+
+    it("gives the submit button a danger class", () => {
+      renderReset({ patron: patrons[0] });
+      expect(
+        screen.getByRole("button", { name: "Reset Adobe ID" })
+      ).toHaveClass("danger");
+    });
+  });
+
+  describe("behavior", () => {
+    it("has a disabled submit button initially", () => {
+      renderReset({ patron: patrons[0], resetAdobeId: jest.fn() });
+      expect(
+        screen.getByRole("button", { name: "Reset Adobe ID" })
+      ).toBeDisabled();
+    });
+
+    it("enables the submit button when the checkbox is checked", async () => {
+      const user = userEvent.setup();
+      renderReset({ patron: patrons[0], resetAdobeId: jest.fn() });
+      const button = screen.getByRole("button", { name: "Reset Adobe ID" });
+      expect(button).toBeDisabled();
+
+      await user.click(screen.getByRole("checkbox"));
+
+      expect(button).not.toBeDisabled();
+    });
+
+    it("disables the submit button when the checkbox is unchecked again", async () => {
+      const user = userEvent.setup();
+      renderReset({ patron: patrons[0], resetAdobeId: jest.fn() });
+      const button = screen.getByRole("button", { name: "Reset Adobe ID" });
+      const checkbox = screen.getByRole("checkbox");
+
+      await user.click(checkbox);
+      expect(button).not.toBeDisabled();
+
+      await user.click(checkbox);
+      expect(button).toBeDisabled();
+    });
+
+    it("calls the Adobe ID action when the button is clicked", async () => {
+      const user = userEvent.setup();
+      const resetAdobeId = jest.fn().mockResolvedValue(undefined);
+      renderReset({ patron: patrons[0], resetAdobeId });
+      expect(resetAdobeId).not.toHaveBeenCalled();
+
+      await user.click(screen.getByRole("checkbox"));
+      const button = screen.getByRole("button", { name: "Reset Adobe ID" });
+      expect(button).not.toBeDisabled();
+      await user.click(button);
+
+      await waitFor(() => expect(resetAdobeId).toHaveBeenCalledTimes(1));
+      const [data, library] = resetAdobeId.mock.calls[0];
+      expect(data.get("identifier")).toBe("1234");
+      expect(library).toBe("nypl");
+
+      // After the reset resolves the component clears the checkbox, re-disabling
+      // the button; awaiting that settles the pending promise.
+      await waitFor(() => expect(button).toBeDisabled());
+    });
+
+    it("shows a success alert message if the reset is successful", () => {
+      const { container, rerender } = renderReset({
+        patron: patrons[0],
+        resetAdobeId: jest.fn().mockResolvedValue(undefined),
+      });
+      expect(container.querySelector(".alert-success")).not.toBeInTheDocument();
+
+      // The response now comes from the server (via the responseBody prop).
+      rerender(
+        resetElement({
+          patron: patrons[0],
+          responseBody: "Adobe ID for patron has been reset.",
+        })
+      );
+
+      const alert = container.querySelector(".alert-success");
+      expect(alert).toBeInTheDocument();
+      expect(alert).toHaveTextContent("Adobe ID for patron has been reset.");
+      expect(alert).toHaveTextContent(
+        "Please instruct the patron to sign back into their account."
+      );
+    });
+
+    it("hides the checkbox and the reset button if the reset is successful", () => {
+      const { container, rerender } = renderReset({
+        patron: patrons[0],
+        resetAdobeId: jest.fn().mockResolvedValue(undefined),
+      });
+      expect(
+        container.querySelector(".reset-adobe-id input")
+      ).toBeInTheDocument();
+      expect(
+        container.querySelector(".reset-adobe-id button")
+      ).toBeInTheDocument();
+
+      rerender(
+        resetElement({
+          patron: patrons[0],
+          responseBody: "Adobe ID for patron has been reset.",
+        })
+      );
+
+      expect(
+        container.querySelector(".reset-adobe-id input")
+      ).not.toBeInTheDocument();
+      expect(
+        container.querySelector(".reset-adobe-id button")
+      ).not.toBeInTheDocument();
+    });
+
+    it("shows a failure alert message if the reset fails", () => {
+      const fetchError = { status: 400, response: "", url: "" };
+      // The legacy test modeled the failing action with a rejecting stub; the
+      // failure alert itself is driven by the fetchError prop the reducer sets.
+      const { container, rerender } = renderReset({
+        patron: patrons[0],
+        resetAdobeId: jest.fn().mockRejectedValue(fetchError),
+      });
+      expect(container.querySelector(".alert-danger")).not.toBeInTheDocument();
+
+      rerender(
+        resetElement({
+          patron: patrons[0],
+          resetAdobeId: jest.fn().mockRejectedValue(fetchError),
+          fetchError,
+        })
+      );
+
+      const alert = container.querySelector(".alert-danger");
+      expect(alert).toBeInTheDocument();
+      expect(alert).toHaveTextContent(
+        "Error: failed to reset Adobe ID for patron 1234"
+      );
+    });
+
+    it("updates the warning message if a new patron is searched and found", () => {
+      const { container, rerender } = renderReset({
+        patron: patrons[0],
+        resetAdobeId: jest.fn(),
+      });
+      expect(container.querySelector(".patron-warning")).toHaveTextContent(
+        "IMPORTANT: Patron User Name will lose access"
+      );
+
+      rerender(resetElement({ patron: patrons[1], resetAdobeId: jest.fn() }));
+
+      expect(container.querySelector(".patron-warning")).toHaveTextContent(
+        "IMPORTANT: Patron Personal Name2 will lose access"
+      );
+    });
+
+    it("restores the checkbox and the reset button if a new patron is searched and found", () => {
+      const { container, rerender } = renderReset({
+        patron: patrons[0],
+        responseBody: "Adobe ID for patron has been reset.",
+        resetAdobeId: jest.fn(),
+      });
+      expect(
+        container.querySelector(".reset-adobe-id input")
+      ).not.toBeInTheDocument();
+      expect(
+        container.querySelector(".reset-adobe-id button")
+      ).not.toBeInTheDocument();
+
+      rerender(
+        resetElement({
+          patron: patrons[0],
+          responseBody: "",
+          resetAdobeId: jest.fn(),
+        })
+      );
+
+      expect(
+        container.querySelector(".reset-adobe-id input")
+      ).toBeInTheDocument();
+      expect(
+        container.querySelector(".reset-adobe-id button")
+      ).toBeInTheDocument();
+    });
+  });
+
+  describe("connected (default export)", () => {
+    it("wires state and dispatch through connect", async () => {
+      // Defensive: nothing fetches on this mount, but stub fetch so any stray
+      // request settles rather than crashing the strict worker.
+      jest.spyOn(globalThis, "fetch").mockResolvedValue(
+        new Response(JSON.stringify({}), {
+          status: 200,
+          headers: { "Content-Type": "application/json" },
+        })
+      );
+
+      renderWithProviders(
+        <ConnectedResetAdobeId
+          store={buildStore()}
+          csrfToken="token"
+          library="nypl"
+        />
+      );
+
+      // With no patron in the store, mapStateToProps yields patron=undefined and
+      // the connected component prompts the user to search.
+      expect(
+        await screen.findByRole("heading", { name: "Reset Adobe ID" })
+      ).toBeInTheDocument();
+      expect(
+        screen.getByText("Search for a patron to begin.")
+      ).toBeInTheDocument();
+    });
+  });
+});