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

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

@@ -0,0 +1,200 @@
+import * as React from "react";
+import { screen } from "@testing-library/react";
+
+import { renderWithProviders } from "../testUtils/withProviders";
+import buildStore from "../../../src/store";
+
+// `SelfTests` is a connected component that fetches self-test results on mount.
+// It is incidental to what `SelfTestsCategory` itself does (build one panel per
+// item, color-code them, decide `openByDefault`, and compute `sortByCollection`),
+// so mock it to a marker that exposes the props the category passes down.
+jest.mock("../../../src/components/SelfTests", () => ({
+  __esModule: true,
+  default: (props: any) => (
+    <div
+      data-testid="self-tests"
+      data-type={props.type}
+      data-item-id={props.item?.id}
+      data-item-name={props.item?.name}
+      data-sort-by-collection={String(props.sortByCollection)}
+    />
+  ),
+}));
+
+import SelfTestsCategory from "../../../src/components/SelfTestsCategory";
+
+const initialSetupResult = {
+  duration: 0.000119,
+  end: "2018-08-07T19:34:54Z",
+  exception: null,
+  name: "Initial setup.",
+  result: null,
+  start: "2018-08-07T19:34:54Z",
+  success: true,
+};
+
+const collections: any[] = [
+  {
+    id: 1,
+    name: "collection with success",
+    protocol: "protocol",
+    self_test_results: {
+      duration: 1.75,
+      start: "2018-08-07T19:34:54Z",
+      end: "2018-08-07T19:34:55Z",
+      results: [initialSetupResult],
+    },
+  },
+  {
+    id: 2,
+    name: "collection with failure",
+    protocol: "protocol",
+    self_test_results: {
+      duration: 1.75,
+      start: "2018-08-07T19:34:54Z",
+      end: "2018-08-07T19:34:55Z",
+      results: [
+        initialSetupResult,
+        {
+          duration: 0,
+          end: "2018-08-07T19:34:55Z",
+          exception: {
+            class: "IntegrationException",
+            debug_message:
+              "Add the collection to a library that has a patron authentication service.",
+            message: "Collection is not associated with any libraries.",
+          },
+          name: "Acquiring test patron credentials.",
+          result: null,
+          start: "2018-08-07T19:34:55Z",
+          success: false,
+        },
+      ],
+    },
+  },
+  {
+    id: 3,
+    name: "collection with no results",
+    protocol: "protocol",
+  },
+];
+
+const renderCategory = (items: any[] = collections) =>
+  renderWithProviders(
+    <SelfTestsCategory
+      type="collection"
+      linkName="collections"
+      csrfToken="token"
+      items={items}
+      store={buildStore()}
+    />
+  );
+
+describe("SelfTestsCategory", () => {
+  it("renders a list of items", () => {
+    const { container } = renderCategory();
+
+    const root = container.querySelector(".self-tests-category");
+    expect(root).toBeInTheDocument();
+    expect(root).toHaveClass("has-additional-content");
+
+    const titles = Array.from(
+      container.querySelectorAll("ul .panel-title")
+    ).map((el) => el.textContent);
+    expect(titles).toStrictEqual([
+      "collection with success",
+      "collection with failure",
+      "collection with no results",
+    ]);
+
+    // One SelfTests per item, each carrying the category's type and its item.
+    const selfTests = screen.getAllByTestId("self-tests");
+    expect(selfTests).toHaveLength(3);
+    selfTests.forEach((el, idx) => {
+      expect(el).toHaveAttribute("data-type", "collection");
+      expect(el).toHaveAttribute("data-item-id", String(collections[idx].id));
+    });
+  });
+
+  it("color-codes", () => {
+    const { container } = renderCategory();
+    const panels = container.querySelectorAll(".panel");
+    expect(panels[0]).toHaveClass("panel-success");
+    expect(panels[1]).toHaveClass("panel-danger");
+    expect(panels[2]).toHaveClass("panel-default");
+  });
+
+  it("opens the panel by default if there's only one", () => {
+    // With multiple items, none are open by default.
+    const multi = renderCategory();
+    expect(
+      Array.from(multi.container.querySelectorAll(".panel-heading")).some(
+        (h) => h.getAttribute("aria-expanded") === "true"
+      )
+    ).toBe(false);
+    multi.unmount();
+
+    // A fresh render with a single item opens that panel by default.
+    // (`openByDefault` seeds the panel's initial state, so a new mount is needed.)
+    const single = renderCategory([collections[0]]);
+    const singleHeaders = single.container.querySelectorAll(".panel-heading");
+    expect(singleHeaders).toHaveLength(1);
+    expect(singleHeaders[0]).toHaveAttribute("aria-expanded", "true");
+  });
+
+  it("passes the sortByCollection prop to SelfTests", () => {
+    const { rerender } = renderCategory();
+    expect(screen.getAllByTestId("self-tests")[0]).toHaveAttribute(
+      "data-sort-by-collection",
+      "false"
+    );
+
+    const withCollection = {
+      id: 99,
+      name: "collection with sorting",
+      protocol: "protocol",
+      self_test_results: {
+        duration: 1.75,
+        start: "2018-08-07T19:34:54Z",
+        end: "2018-08-07T19:34:55Z",
+        results: [{ ...initialSetupResult, collection: "sort!" }],
+      },
+    };
+
+    rerender(
+      <SelfTestsCategory
+        type="collection"
+        linkName="collections"
+        csrfToken="token"
+        items={[withCollection, ...collections]}
+        store={buildStore()}
+      />
+    );
+
+    expect(screen.getAllByTestId("self-tests")[0]).toHaveAttribute(
+      "data-sort-by-collection",
+      "true"
+    );
+  });
+
+  it("handles unnamed items", () => {
+    const nameless: any = {
+      id: 1,
+      name: null,
+      protocol: "protocol",
+      self_test_results: {
+        duration: 1.75,
+        start: "2018-08-07T19:34:54Z",
+        end: "2018-08-07T19:34:55Z",
+        results: [initialSetupResult],
+      },
+    };
+    const { container } = renderCategory([nameless]);
+
+    expect(screen.getByText("Unnamed collection")).toHaveClass("panel-title");
+    // Panel id becomes `${name-without-spaces}-${id}`; its body id appends "-panel".
+    expect(
+      container.querySelector("#Unnamedcollection-1-panel")
+    ).toBeInTheDocument();
+  });
+});

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

@@ -0,0 +1,110 @@
+import * as React from "react";
+import { render, screen } from "@testing-library/react";
+
+import { DiscoveryServicesData } from "../../../src/interfaces";
+import ServiceWithRegistrationsEditForm from "../../../src/components/ServiceWithRegistrationsEditForm";
+
+// `ServiceWithRegistrationsEditForm` is generic/abstract over its data type;
+// the legacy test subclassed it to bind the discovery-services data type.
+class DiscoveryServiceEditForm extends ServiceWithRegistrationsEditForm<DiscoveryServicesData> {}
+
+const serviceData = {
+  id: 1,
+  protocol: "protocol 1",
+};
+const protocolsData = [
+  {
+    name: "protocol 1",
+    label: "protocol 1 label",
+    supports_registration: true,
+    settings: [],
+    library_settings: [],
+  },
+];
+const allLibraries = [
+  { short_name: "nypl", name: "New York Public Library" },
+  { short_name: "bpl", name: "Brooklyn Public Library" },
+  { short_name: "qpl", name: "Queens Public Library" },
+];
+const libraryRegistrationsData = [
+  {
+    id: 1,
+    libraries: [
+      { short_name: "nypl", status: "success", stage: "production" },
+      { short_name: "bpl", status: "failure", stage: "testing" },
+    ],
+  },
+];
+const servicesData: any = {
+  discovery_services: [serviceData],
+  protocols: protocolsData,
+  allLibraries: allLibraries,
+  libraryRegistrations: libraryRegistrationsData,
+};
+
+const renderForm = (save = jest.fn()) =>
+  render(
+    <DiscoveryServiceEditForm
+      disabled={false}
+      data={servicesData}
+      item={serviceData as any}
+      save={save}
+      urlBase="url base"
+      listDataKey="discovery_services"
+    />
+  );
+
+describe("ServiceWithRegistrationsEditForm", () => {
+  it("renders the underlying service edit form fields", () => {
+    renderForm();
+
+    // The base ServiceEditForm (via `super.render()`) contributes the Name text
+    // field and the Required Fields section.
+    expect(screen.getByRole("textbox")).toBeInTheDocument();
+    expect(
+      screen.getByRole("heading", { name: "Required Fields" })
+    ).toBeInTheDocument();
+  });
+
+  it("renders a registration section reflecting each library's status", () => {
+    renderForm();
+
+    // The registration UI only renders when the protocol supports registration
+    // and the data carries libraries — i.e. those props flowed to LibraryRegistration.
+    expect(
+      screen.getByRole("heading", { name: "Register libraries" })
+    ).toBeInTheDocument();
+
+    expect(
+      screen.getByRole("link", { name: "New York Public Library" })
+    ).toBeInTheDocument();
+    expect(
+      screen.getByRole("link", { name: "Brooklyn Public Library" })
+    ).toBeInTheDocument();
+    expect(
+      screen.getByRole("link", { name: "Queens Public Library" })
+    ).toBeInTheDocument();
+
+    // Statuses come from `data.libraryRegistrations`.
+    expect(screen.getByText("Registered")).toHaveClass("bg-success");
+    expect(screen.getByText("Registration failed")).toHaveClass("bg-danger");
+    expect(screen.getByText("Not registered")).toHaveClass("bg-warning");
+  });
+
+  it("enables the per-library registration actions when not disabled", () => {
+    renderForm();
+
+    // `disabled={false}` flows through to each registration button.
+    const updateButton = screen.getByRole("button", {
+      name: "Update registration",
+    });
+    const retryButton = screen.getByRole("button", {
+      name: "Retry registration",
+    });
+    const registerButton = screen.getByRole("button", { name: "Register" });
+
+    expect(updateButton).not.toBeDisabled();
+    expect(retryButton).not.toBeDisabled();
+    expect(registerButton).not.toBeDisabled();
+  });
+});

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

@@ -0,0 +1,41 @@
+import * as React from "react";
+import { screen } from "@testing-library/react";
+
+import { renderWithProviders } from "../testUtils/withProviders";
+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" },
+      })
+    );
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it("shows the individual-admins setup (create) form", async () => {
+    renderWithProviders(<SetupPage />);
+
+    // SetupPage wires IndividualAdmins with settingUp + editOrCreate="create".
+    // That combination renders the "Welcome!" heading and the
+    // "Set up your system admin account" create-form heading; their presence in
+    // the real DOM proves the child received those props (the original shallow
+    // test asserted the props directly). No identifier is passed, so there is no
+    // per-item "Edit ..." heading — only the create form shows.
+    expect(
+      await screen.findByRole("heading", { name: "Welcome!" })
+    ).toBeInTheDocument();
+    expect(
+      screen.getByRole("heading", {
+        name: "Set up your system admin account",
+      })
+    ).toBeInTheDocument();
+  });
+});

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

@@ -0,0 +1,62 @@
+import * as React from "react";
+import { render, screen } from "@testing-library/react";
+
+import SingleStatListItem, {
+  SingleStatListItemProps,
+} from "../../../src/components/SingleStatListItem";
+
+describe("SingleStatListItem", () => {
+  const statWithTooltip: SingleStatListItemProps = {
+    label: "Number of Widgets",
+    value: 357892,
+    tooltip: "Total Widget Count",
+  };
+  const humanReadableValue = "357.9k";
+  const formattedValue = "357,892";
+
+  it("renders a top-level <li>, with or without a tooltip", () => {
+    const { container, rerender } = render(
+      <SingleStatListItem {...statWithTooltip} />
+    );
+    expect(container.firstElementChild?.tagName).toBe("LI");
+    expect(container.firstElementChild).toHaveClass("single-stat");
+
+    // Without a tooltip the <li> is still the top-level element.
+    rerender(
+      <SingleStatListItem
+        label={statWithTooltip.label}
+        value={statWithTooltip.value}
+      />
+    );
+    expect(container.firstElementChild?.tagName).toBe("LI");
+    expect(container.firstElementChild).toHaveClass("single-stat");
+  });
+
+  it("shows a tooltip wrapping the value and label when one is provided", () => {
+    const { container } = render(<SingleStatListItem {...statWithTooltip} />);
+
+    const tooltip = container.querySelector('[data-toggle="tooltip"]');
+    expect(tooltip).not.toBeNull();
+
+    const title = tooltip?.getAttribute("title") ?? "";
+    expect(title).toContain(statWithTooltip.tooltip);
+    expect(title).toContain(formattedValue);
+
+    // When there's a tooltip, it wraps the (rounded) value and the label.
+    expect(tooltip).toHaveTextContent(humanReadableValue);
+    expect(tooltip).toHaveTextContent(statWithTooltip.label);
+  });
+
+  it("omits the tooltip when none is provided, showing value and label directly", () => {
+    const { container } = render(
+      <SingleStatListItem
+        label={statWithTooltip.label}
+        value={statWithTooltip.value}
+      />
+    );
+
+    expect(container.querySelector('[data-toggle="tooltip"]')).toBeNull();
+    expect(screen.getByText(humanReadableValue)).toBeInTheDocument();
+    expect(screen.getByText(statWithTooltip.label)).toBeInTheDocument();
+  });
+});

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

@@ -382,14 +382,10 @@ describe("Dashboard Statistics", () => {
             roles,
             quicksightPagePath: fakeQuickSightHref,
           };
-          const {
-            container,
-            getByRole,
-            queryByRole,
-            queryByText,
-          } = renderWithProviders(<Stats library={sampleLibraryKey} />, {
-            appConfigSettings,
-          });
+          const { container, getByRole, queryByRole, queryByText } =
+            renderWithProviders(<Stats library={sampleLibraryKey} />, {
+              appConfigSettings,
+            });
 
           // We should always render a Usage reports group when a library is specified.
           getByRole("heading", {

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

@@ -0,0 +1,68 @@
+import * as React from "react";
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+
+import {
+  TabContainer,
+  TabContainerProps,
+} from "../../../src/components/TabContainer";
+
+describe("TabContainer", () => {
+  let handleSelectSpy: jest.Mock;
+
+  // A concrete subclass of the abstract TabContainer, mirroring the legacy test's
+  // MockTabContainer: it supplies two trivial tabs and records the selected tab
+  // key when handleSelect runs.
+  class MockTabContainer extends TabContainer<TabContainerProps> {
+    handleSelect(event) {
+      handleSelectSpy(event.target.dataset.tabkey);
+    }
+    tabs() {
+      return {
+        tab1: <div className="tab1" />,
+        tab2: <div className="tab2" />,
+      };
+    }
+  }
+
+  const renderContainer = (tab: string = null) =>
+    render(
+      <MockTabContainer tab={tab} csrfToken="token">
+        <div className="test-child">Moby Dick</div>
+      </MockTabContainer>
+    );
+
+  beforeEach(() => {
+    handleSelectSpy = jest.fn();
+  });
+
+  it("shows nav tabs", () => {
+    const { container } = renderContainer();
+    const items = container.querySelectorAll("ul.nav-tabs li");
+    const linkTexts = Array.from(items).map((li) => li.textContent);
+    expect(linkTexts).toContain("Tab1");
+    expect(linkTexts).toContain("Tab2");
+    expect(items[0]).toHaveClass("active");
+    expect(items[1]).not.toHaveClass("active");
+  });
+
+  it("shows default tab content", () => {
+    const { container } = renderContainer();
+    expect(container.querySelector("#tab1")).toHaveStyle({ display: "block" });
+    expect(container.querySelector("#tab2")).toHaveStyle({ display: "none" });
+  });
+
+  it("shows tab content from tab in props", () => {
+    const { container } = renderContainer("tab2");
+    expect(container.querySelector("#tab1")).toHaveStyle({ display: "none" });
+    expect(container.querySelector("#tab2")).toHaveStyle({ display: "block" });
+  });
+
+  it("uses handleSelect to navigate when tab is clicked", async () => {
+    const user = userEvent.setup();
+    renderContainer();
+    await user.click(screen.getByRole("link", { name: "Tab2" }));
+    expect(handleSelectSpy).toHaveBeenCalledTimes(1);
+    expect(handleSelectSpy).toHaveBeenCalledWith("tab2");
+  });
+});

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

@@ -0,0 +1,74 @@
+import * as React from "react";
+import { render, screen } from "@testing-library/react";
+
+import Timestamp from "../../../src/components/Timestamp";
+
+describe("Timestamp", () => {
+  const timestamp = {
+    service: "test_service",
+    id: "1",
+    start: "start_time_string",
+    duration: "60",
+    collection_name: "collection1",
+  };
+
+  describe("rendering", () => {
+    it("renders a success panel that is not collapsible", () => {
+      const { container } = render(<Timestamp timestamp={timestamp} />);
+
+      expect(container.querySelector(".panel-success")).toBeInTheDocument();
+      expect(container.querySelector(".panel-danger")).not.toBeInTheDocument();
+      // A non-collapsible panel is a static panel with no toggle button.
+      expect(container.querySelector(".static-panel")).toBeInTheDocument();
+      expect(screen.queryByRole("button")).not.toBeInTheDocument();
+    });
+
+    it("renders the start time", () => {
+      const { container } = render(<Timestamp timestamp={timestamp} />);
+
+      expect(container.querySelector(".panel-title")).toHaveTextContent(
+        "start_time_string"
+      );
+    });
+
+    it("renders the duration", () => {
+      const { container } = render(<Timestamp timestamp={timestamp} />);
+
+      expect(container.querySelectorAll("ul li")).toHaveLength(1);
+      expect(screen.getByText("Duration: 60 seconds")).toBeInTheDocument();
+    });
+  });
+
+  describe("rendering with achievements", () => {
+    it("renders achievements", () => {
+      const { container } = render(
+        <Timestamp timestamp={{ ...timestamp, achievements: "Ran a script" }} />
+      );
+
+      expect(container.querySelectorAll("ul li")).toHaveLength(2);
+      const achievements = container.querySelector(".well pre");
+      expect(achievements).toBeInTheDocument();
+      expect(achievements).toHaveTextContent("Ran a script");
+    });
+  });
+
+  describe("rendering with exception", () => {
+    it("determines style based on whether there is an exception", () => {
+      const { container } = render(
+        <Timestamp timestamp={{ ...timestamp, exception: "Stack trace" }} />
+      );
+
+      expect(container.querySelector(".panel-danger")).toBeInTheDocument();
+    });
+
+    it("renders an exception", () => {
+      const { container } = render(
+        <Timestamp timestamp={{ ...timestamp, exception: "Stack trace" }} />
+      );
+
+      const exception = container.querySelector(".exception pre");
+      expect(exception).toBeInTheDocument();
+      expect(exception).toHaveTextContent("Stack trace");
+    });
+  });
+});

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

@@ -0,0 +1,68 @@
+import * as React from "react";
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+
+// The tab content (TroubleshootingCategoryPage) renders the connected
+// Diagnostics/Self-tests containers, which need Redux store + csrf context this
+// test does not supply. That content is incidental here — the test is about the
+// tab navigation — so mock it to a marker.
+jest.mock("../../../src/components/TroubleshootingCategoryPage", () => ({
+  __esModule: true,
+  default: () => <div data-testid="category-page" />,
+}));
+
+import TroubleshootingTabContainer from "../../../src/components/TroubleshootingTabContainer";
+
+describe("TroubleshootingTabContainer", () => {
+  let goToTab: jest.Mock;
+
+  beforeEach(() => {
+    goToTab = jest.fn();
+  });
+
+  it("renders tabs and defaults to showing the Diagnostics tab", () => {
+    const { container } = render(
+      <TroubleshootingTabContainer goToTab={goToTab} tab="diagnostics" />
+    );
+
+    const nav = container.querySelector("ul.nav-tabs");
+    expect(nav).not.toBeNull();
+
+    const tabs = nav.querySelectorAll("li");
+    expect(tabs).toHaveLength(2);
+
+    expect(tabs[0]).toHaveTextContent("Diagnostics");
+    expect(tabs[0]).toHaveClass("active");
+
+    expect(tabs[1]).toHaveTextContent("Self-tests");
+    expect(tabs[1]).not.toHaveClass("active");
+  });
+
+  it("calls goToTab when another tab is clicked", async () => {
+    const user = userEvent.setup();
+    render(<TroubleshootingTabContainer goToTab={goToTab} tab="diagnostics" />);
+
+    await user.click(screen.getByRole("link", { name: "Self-tests" }));
+
+    expect(goToTab).toHaveBeenCalledTimes(1);
+    expect(goToTab).toHaveBeenCalledWith("self-tests");
+  });
+
+  it("switches the active tab when the tab prop changes", () => {
+    const { container, rerender } = render(
+      <TroubleshootingTabContainer goToTab={goToTab} tab="diagnostics" />
+    );
+
+    let tabs = container.querySelectorAll("ul.nav-tabs li");
+    expect(tabs[0]).toHaveClass("active");
+    expect(tabs[1]).not.toHaveClass("active");
+
+    rerender(
+      <TroubleshootingTabContainer goToTab={goToTab} tab="self-tests" />
+    );
+
+    tabs = container.querySelectorAll("ul.nav-tabs li");
+    expect(tabs[0]).not.toHaveClass("active");
+    expect(tabs[1]).toHaveClass("active");
+  });
+});

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

@@ -0,0 +1,36 @@
+import * as React from "react";
+import { render, screen } from "@testing-library/react";
+
+import UpdatingLoader from "../../../src/components/UpdatingLoader";
+
+describe("UpdatingLoader", () => {
+  it("renders only its container when not showing", () => {
+    const { container } = render(<UpdatingLoader show={false} />);
+
+    expect(
+      container.querySelector(".updating-loader-container")
+    ).toBeInTheDocument();
+    expect(container.querySelector(".updating-loader")).not.toBeInTheDocument();
+    expect(screen.queryByText("Updating")).not.toBeInTheDocument();
+  });
+
+  it("renders the default message when showing", () => {
+    render(<UpdatingLoader show={true} />);
+
+    expect(screen.getByText("Updating")).toBeInTheDocument();
+  });
+
+  it("renders the text it is given instead of the default", () => {
+    render(<UpdatingLoader show={true} text="Doing something" />);
+
+    expect(screen.getByText("Doing something")).toBeInTheDocument();
+    expect(screen.queryByText("Updating")).not.toBeInTheDocument();
+  });
+
+  it("renders a spinner", () => {
+    const { container } = render(<UpdatingLoader show={true} />);
+
+    // The spinner is a Font Awesome <i>, which carries no accessible role.
+    expect(container.querySelector("i.fa-spinner")).toBeInTheDocument();
+  });
+});