@thepalaceproject/circulation-admin 1.36.0 → 1.37.0-post.2

package/package.json

@@ -152,5 +152,5 @@
     "*.{js,jsx,ts,tsx,css,md}": "prettier --write",
     "*.{js,css,md}": "prettier --write"
   },
-  "version": "1.36.0"
+  "version": "1.37.0-post.2"
 }

package/tests/jest/api/patronBlockingRules.test.ts

@@ -0,0 +1,78 @@
+import * as fetchMock from "fetch-mock-jest";
+import { validatePatronBlockingRuleExpression } from "../../../src/api/patronBlockingRules";
+import { PatronBlockingRule } from "../../../src/interfaces";
+
+const VALIDATE_URL = "/admin/patron_auth_service_validate_patron_blocking_rule";
+
+const sampleRule: PatronBlockingRule = {
+  name: "Fine Check",
+  rule: "{fines} > 10.0",
+};
+
+describe("validatePatronBlockingRuleExpression", () => {
+  afterEach(() => {
+    fetchMock.mockReset();
+  });
+
+  it("returns null on a 200 response", async () => {
+    fetchMock.post(VALIDATE_URL, { status: 200 });
+    const result = await validatePatronBlockingRuleExpression(
+      42,
+      sampleRule,
+      "test-token"
+    );
+    expect(result).toBeNull();
+  });
+
+  it("returns the detail string from a 400 response", async () => {
+    fetchMock.post(VALIDATE_URL, {
+      status: 400,
+      body: { detail: "Unknown placeholder: {unknown_field}" },
+    });
+    const result = await validatePatronBlockingRuleExpression(
+      42,
+      sampleRule,
+      "test-token"
+    );
+    expect(result).toBe("Unknown placeholder: {unknown_field}");
+  });
+
+  it("returns a fallback string when a 400 response body has no detail", async () => {
+    fetchMock.post(VALIDATE_URL, { status: 400, body: {} });
+    const result = await validatePatronBlockingRuleExpression(
+      42,
+      sampleRule,
+      "test-token"
+    );
+    expect(result).not.toBeNull();
+    expect(typeof result).toBe("string");
+  });
+
+  it("sends the correct URL, method, and CSRF header", async () => {
+    fetchMock.post(VALIDATE_URL, { status: 200 });
+    await validatePatronBlockingRuleExpression(42, sampleRule, "my-csrf-token");
+    expect(fetchMock).toHaveBeenCalledWith(
+      VALIDATE_URL,
+      expect.objectContaining({
+        method: "POST",
+        headers: expect.objectContaining({ "X-CSRF-Token": "my-csrf-token" }),
+      })
+    );
+  });
+
+  it("omits service_id from the form body when serviceId is undefined", async () => {
+    fetchMock.post(VALIDATE_URL, { status: 200 });
+    // Should not throw and should still make the request (server returns "save first" error)
+    const result = await validatePatronBlockingRuleExpression(
+      undefined,
+      sampleRule,
+      "tok"
+    );
+    expect(fetchMock).toHaveBeenCalledWith(
+      VALIDATE_URL,
+      expect.objectContaining({ method: "POST" })
+    );
+    // Server would return an error detail in a real call; here it returns 200 (mocked)
+    expect(result).toBeNull();
+  });
+});

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

@@ -0,0 +1,281 @@
+import * as React from "react";
+import { setupServer } from "msw/node";
+import { http, HttpResponse } from "msw";
+import { QueryClient } from "@tanstack/react-query";
+import { renderWithProviders } from "../testUtils/withProviders";
+import DebugAuthentication from "../../../src/components/DebugAuthentication";
+import {
+  AuthMethodsResponse,
+  PatronDebugResponse,
+} from "../../../src/api/patronDebug";
+import { waitFor, fireEvent } from "@testing-library/react";
+
+const LIBRARY = "test-library";
+const SECOND_LIBRARY = "another-library";
+const AUTH_METHODS_PATH = `/${LIBRARY}/admin/manage_patrons/auth_methods`;
+const DEBUG_AUTH_PATH = `/${LIBRARY}/admin/manage_patrons/debug_auth`;
+const SECOND_AUTH_METHODS_PATH = `/${SECOND_LIBRARY}/admin/manage_patrons/auth_methods`;
+
+const MOCK_AUTH_METHODS: AuthMethodsResponse = {
+  authMethods: [
+    {
+      id: 1,
+      name: "Test SIP2",
+      protocol: "api.sip",
+      supportsDebug: true,
+      supportsPassword: true,
+      identifierLabel: "Barcode",
+      passwordLabel: "PIN",
+    },
+    {
+      id: 2,
+      name: "SAML Provider",
+      protocol: "api.saml.provider",
+      supportsDebug: false,
+      supportsPassword: false,
+      identifierLabel: "Username",
+      passwordLabel: "Password",
+    },
+  ],
+};
+
+const MOCK_DEBUG_RESULTS: PatronDebugResponse = {
+  results: [
+    { label: "Server-Side Validation", success: true, details: "ok" },
+    {
+      label: "SIP2 Connection",
+      success: true,
+      details: "sip.example.com:6001",
+    },
+    {
+      label: "Password Validation",
+      success: false,
+      details: "valid_patron_password=N",
+    },
+  ],
+};
+
+describe("DebugAuthentication", () => {
+  /* eslint-disable @typescript-eslint/no-empty-function */
+  const queryClient = new QueryClient({
+    defaultOptions: {
+      queries: {
+        retry: false,
+      },
+    },
+    logger: {
+      log: console.log,
+      warn: console.warn,
+      error: process.env.NODE_ENV === "test" ? () => {} : console.error,
+    },
+  });
+  /* eslint-enable @typescript-eslint/no-empty-function */
+
+  const server = setupServer(
+    http.get(AUTH_METHODS_PATH, () =>
+      HttpResponse.json(MOCK_AUTH_METHODS, { status: 200 })
+    ),
+    http.post(DEBUG_AUTH_PATH, () =>
+      HttpResponse.json(MOCK_DEBUG_RESULTS, { status: 200 })
+    )
+  );
+
+  beforeAll(() => server.listen());
+  afterEach(() => {
+    server.resetHandlers();
+    queryClient.clear();
+  });
+  afterAll(() => server.close());
+
+  const renderComponent = () => {
+    return renderWithProviders(
+      <DebugAuthentication library={LIBRARY} csrfToken="test-csrf-token" />,
+      { queryClient }
+    );
+  };
+
+  it("displays loading state initially", () => {
+    const { getByText } = renderComponent();
+    expect(getByText("Loading authentication methods...")).toBeInTheDocument();
+  });
+
+  it("renders auth method dropdown after loading", async () => {
+    const { getByLabelText, getByText } = renderComponent();
+    await waitFor(() => {
+      expect(getByLabelText("Authentication Method")).toBeInTheDocument();
+    });
+    expect(getByText("Test SIP2 (api.sip)")).toBeInTheDocument();
+    expect(getByText("SAML Provider (api.saml.provider)")).toBeInTheDocument();
+  });
+
+  it("shows 'not supported' message for non-debug methods", async () => {
+    const { getByLabelText, getByText } = renderComponent();
+    await waitFor(() => {
+      expect(getByLabelText("Authentication Method")).toBeInTheDocument();
+    });
+
+    fireEvent.change(getByLabelText("Authentication Method"), {
+      target: { value: "2" },
+    });
+
+    expect(
+      getByText(
+        "Debug authentication is not supported for this authentication method."
+      )
+    ).toBeInTheDocument();
+  });
+
+  it("shows form fields for debug-capable method", async () => {
+    const { getByLabelText, getByText } = renderComponent();
+    await waitFor(() => {
+      expect(getByLabelText("Authentication Method")).toBeInTheDocument();
+    });
+
+    fireEvent.change(getByLabelText("Authentication Method"), {
+      target: { value: "1" },
+    });
+
+    // Should show fields with the method's labels
+    expect(getByLabelText("Barcode")).toBeInTheDocument();
+    expect(getByLabelText("PIN")).toBeInTheDocument();
+    expect(getByText("Run Debug")).toBeInTheDocument();
+  });
+
+  it("runs debug and displays results", async () => {
+    const { getByLabelText, getByText } = renderComponent();
+    await waitFor(() => {
+      expect(getByLabelText("Authentication Method")).toBeInTheDocument();
+    });
+
+    // Select the SIP2 method
+    fireEvent.change(getByLabelText("Authentication Method"), {
+      target: { value: "1" },
+    });
+
+    // Fill in the form
+    fireEvent.change(getByLabelText("Barcode"), {
+      target: { value: "12345" },
+    });
+    fireEvent.change(getByLabelText("PIN"), {
+      target: { value: "1111" },
+    });
+
+    // Submit
+    fireEvent.click(getByText("Run Debug"));
+
+    // Wait for results
+    await waitFor(() => {
+      expect(getByText("Server-Side Validation")).toBeInTheDocument();
+    });
+    expect(getByText("SIP2 Connection")).toBeInTheDocument();
+    expect(getByText("Password Validation")).toBeInTheDocument();
+  });
+
+  it("auto-selects and hides dropdown when there is only one method", async () => {
+    const singleMethod: AuthMethodsResponse = {
+      authMethods: [MOCK_AUTH_METHODS.authMethods[0]],
+    };
+    server.use(
+      http.get(AUTH_METHODS_PATH, () =>
+        HttpResponse.json(singleMethod, { status: 200 })
+      )
+    );
+
+    const { getByLabelText, queryByLabelText } = renderComponent();
+
+    // The form fields should appear automatically without selecting a method.
+    await waitFor(() => {
+      expect(getByLabelText("Barcode")).toBeInTheDocument();
+    });
+    expect(getByLabelText("PIN")).toBeInTheDocument();
+
+    // The dropdown should not be rendered.
+    expect(queryByLabelText("Authentication Method")).not.toBeInTheDocument();
+  });
+
+  it("reconciles selected method when switching to a different library", async () => {
+    const singleMethodForSecondLibrary: AuthMethodsResponse = {
+      authMethods: [
+        {
+          id: 99,
+          name: "Second Library API",
+          protocol: "api.second",
+          supportsDebug: true,
+          supportsPassword: false,
+          identifierLabel: "Email",
+          passwordLabel: "Password",
+        },
+      ],
+    };
+
+    server.use(
+      http.get(SECOND_AUTH_METHODS_PATH, () =>
+        HttpResponse.json(singleMethodForSecondLibrary, { status: 200 })
+      )
+    );
+
+    const {
+      getByLabelText,
+      queryByLabelText,
+      rerender,
+    } = renderWithProviders(
+      <DebugAuthentication library={LIBRARY} csrfToken="test-csrf-token" />,
+      { queryClient }
+    );
+
+    await waitFor(() => {
+      expect(getByLabelText("Authentication Method")).toBeInTheDocument();
+    });
+
+    fireEvent.change(getByLabelText("Authentication Method"), {
+      target: { value: "1" },
+    });
+    expect(getByLabelText("Barcode")).toBeInTheDocument();
+
+    rerender(
+      <DebugAuthentication
+        library={SECOND_LIBRARY}
+        csrfToken="test-csrf-token"
+      />
+    );
+
+    await waitFor(() => {
+      expect(getByLabelText("Email")).toBeInTheDocument();
+    });
+    expect(queryByLabelText("Authentication Method")).not.toBeInTheDocument();
+  });
+
+  it("shows warning when library has no auth methods", async () => {
+    server.use(
+      http.get(AUTH_METHODS_PATH, () =>
+        HttpResponse.json({ authMethods: [] }, { status: 200 })
+      )
+    );
+
+    const { getByText, queryByLabelText } = renderComponent();
+    await waitFor(() => {
+      expect(
+        getByText(
+          "This library has no patron authentication integrations configured."
+        )
+      ).toBeInTheDocument();
+    });
+    expect(queryByLabelText("Authentication Method")).not.toBeInTheDocument();
+  });
+
+  it("handles API error on fetching auth methods", async () => {
+    server.use(
+      http.get(AUTH_METHODS_PATH, () => new HttpResponse(null, { status: 500 }))
+    );
+
+    const { getByText } = renderComponent();
+    await waitFor(
+      () => {
+        expect(
+          getByText(/Error loading authentication methods/)
+        ).toBeInTheDocument();
+      },
+      { timeout: 5000 }
+    );
+  });
+});

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

@@ -0,0 +1,162 @@
+import * as React from "react";
+import { render } from "@testing-library/react";
+import DebugResultListItem from "../../../src/components/DebugResultListItem";
+import { PatronDebugResult } from "../../../src/api/patronDebug";
+
+describe("DebugResultListItem", () => {
+  const renderResult = (result: PatronDebugResult, sequence = 0) => {
+    return render(<DebugResultListItem result={result} sequence={sequence} />);
+  };
+
+  it("renders success result with string details", () => {
+    const result: PatronDebugResult = {
+      label: "SIP2 Connection",
+      success: true,
+      details: "Connected to server:6001",
+    };
+    const { getByText } = renderResult(result);
+    expect(getByText("SIP2 Connection")).toBeInTheDocument();
+    expect(getByText("passed")).toBeInTheDocument();
+    expect(getByText("Connected to server:6001")).toBeInTheDocument();
+  });
+
+  it("renders failure result with string details", () => {
+    const result: PatronDebugResult = {
+      label: "Password Validation",
+      success: false,
+      details: "Password does not match",
+    };
+    const { getByText, container } = renderResult(result);
+    expect(getByText("Password Validation")).toBeInTheDocument();
+    expect(getByText("failed")).toBeInTheDocument();
+    const li = container.querySelector("li");
+    expect(li).toHaveClass("failure");
+  });
+
+  it("renders success result with CSS class", () => {
+    const result: PatronDebugResult = {
+      label: "Step 1",
+      success: true,
+      details: null,
+    };
+    const { container } = renderResult(result);
+    const li = container.querySelector("li");
+    expect(li).toHaveClass("success");
+  });
+
+  it("renders null details without detail section", () => {
+    const result: PatronDebugResult = {
+      label: "Step 1",
+      success: true,
+      details: null,
+    };
+    const { container } = renderResult(result);
+    expect(container.querySelector(".debug-result-detail")).toBeNull();
+    expect(container.querySelector(".debug-result-table")).toBeNull();
+    expect(container.querySelector(".debug-result-list")).toBeNull();
+  });
+
+  it("renders list details as ordered list in panel", () => {
+    const result: PatronDebugResult = {
+      label: "Multi Result",
+      success: true,
+      details: ["item one", "item two", "item three"],
+    };
+    const { getByText, container } = renderResult(result);
+    expect(getByText("item one")).toBeInTheDocument();
+    expect(getByText("item two")).toBeInTheDocument();
+    expect(getByText("item three")).toBeInTheDocument();
+    const ol = container.querySelector(".debug-result-list");
+    expect(ol).toBeInTheDocument();
+  });
+
+  it("renders dict details as key-value table in panel", () => {
+    const result: PatronDebugResult = {
+      label: "Patron Data",
+      success: true,
+      details: {
+        username: "jdoe",
+        barcode: "12345",
+        fines: "0.00",
+      },
+    };
+    const { getByText, container } = renderResult(result);
+    expect(getByText("username")).toBeInTheDocument();
+    expect(getByText("jdoe")).toBeInTheDocument();
+    expect(getByText("barcode")).toBeInTheDocument();
+    expect(getByText("12345")).toBeInTheDocument();
+    const table = container.querySelector(".debug-result-table");
+    expect(table).toBeInTheDocument();
+  });
+
+  it("renders dict details with nested object values as JSON", () => {
+    const result: PatronDebugResult = {
+      label: "SirsiDynix Data",
+      success: true,
+      details: {
+        patronType: { key: "testtype", label: "Test Type" },
+        name: "Jane Doe",
+      },
+    };
+    const { getByText, container } = renderResult(result);
+    expect(getByText("patronType")).toBeInTheDocument();
+    // Nested object should render as pretty-printed JSON inside a <code> tag
+    const codeEl = container.querySelector(
+      "td.debug-result-value code"
+    ) as HTMLElement;
+    expect(codeEl).toBeInTheDocument();
+    expect(codeEl.textContent).toBe(
+      JSON.stringify({ key: "testtype", label: "Test Type" }, null, 2)
+    );
+    expect(getByText("name")).toBeInTheDocument();
+    expect(getByText("Jane Doe")).toBeInTheDocument();
+  });
+
+  it("renders top-level number details as text content", () => {
+    const result: PatronDebugResult = {
+      label: "Retry Count",
+      success: true,
+      details: 3,
+    };
+    const { getByText, container } = renderResult(result);
+    expect(getByText("Retry Count")).toBeInTheDocument();
+    expect(getByText("3")).toBeInTheDocument();
+    expect(container.querySelector(".debug-result-table")).toBeNull();
+  });
+
+  it("renders top-level boolean details as text content", () => {
+    const result: PatronDebugResult = {
+      label: "Eligibility",
+      success: false,
+      details: false,
+    };
+    const { getByText, container } = renderResult(result);
+    expect(getByText("Eligibility")).toBeInTheDocument();
+    expect(getByText("false")).toBeInTheDocument();
+    expect(container.querySelector(".debug-result-table")).toBeNull();
+  });
+
+  it("renders dict details with mixed value types (number, boolean, null)", () => {
+    const result: PatronDebugResult = {
+      label: "Mixed Data",
+      success: true,
+      details: {
+        username: "jdoe",
+        fines: 2.5,
+        active: true,
+        block_reason: null,
+      },
+    };
+    const { getByText, container } = renderResult(result);
+    expect(getByText("username")).toBeInTheDocument();
+    expect(getByText("jdoe")).toBeInTheDocument();
+    expect(getByText("fines")).toBeInTheDocument();
+    expect(getByText("2.5")).toBeInTheDocument();
+    expect(getByText("active")).toBeInTheDocument();
+    expect(getByText("true")).toBeInTheDocument();
+    expect(getByText("block_reason")).toBeInTheDocument();
+    expect(getByText("null")).toBeInTheDocument();
+    const table = container.querySelector(".debug-result-table");
+    expect(table).toBeInTheDocument();
+  });
+});

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

@@ -0,0 +1,81 @@
+import * as React from "react";
+import { render, fireEvent } from "@testing-library/react";
+import PasswordInput from "../../../src/components/PasswordInput";
+
+describe("PasswordInput", () => {
+  it("defaults to type='password'", () => {
+    const { getByLabelText } = render(
+      <label>
+        PIN
+        <PasswordInput />
+      </label>
+    );
+    expect(getByLabelText("PIN")).toHaveAttribute("type", "password");
+  });
+
+  it("toggles to type='text' when show button is clicked", () => {
+    const { getByLabelText } = render(
+      <label>
+        PIN
+        <PasswordInput />
+      </label>
+    );
+    const input = getByLabelText("PIN");
+    const toggleBtn = getByLabelText("Show password");
+
+    fireEvent.click(toggleBtn);
+    expect(input).toHaveAttribute("type", "text");
+
+    fireEvent.click(getByLabelText("Hide password"));
+    expect(input).toHaveAttribute("type", "password");
+  });
+
+  it("has correct aria-label on toggle button", () => {
+    const { getByLabelText, queryByLabelText } = render(
+      <label>
+        PIN
+        <PasswordInput />
+      </label>
+    );
+
+    expect(getByLabelText("Show password")).toBeInTheDocument();
+    expect(queryByLabelText("Hide password")).not.toBeInTheDocument();
+
+    fireEvent.click(getByLabelText("Show password"));
+
+    expect(getByLabelText("Hide password")).toBeInTheDocument();
+    expect(queryByLabelText("Show password")).not.toBeInTheDocument();
+  });
+
+  it("passes through standard input props", () => {
+    const handleChange = jest.fn();
+    const { getByLabelText } = render(
+      <label>
+        PIN
+        <PasswordInput
+          id="test-pw"
+          className="form-control"
+          value="secret"
+          onChange={handleChange}
+          autoComplete="off"
+        />
+      </label>
+    );
+
+    const input = getByLabelText("PIN");
+    expect(input).toHaveAttribute("id", "test-pw");
+    expect(input).toHaveClass("form-control");
+    expect(input).toHaveAttribute("value", "secret");
+    expect(input).toHaveAttribute("autoComplete", "off");
+
+    fireEvent.change(input, { target: { value: "new-value" } });
+    expect(handleChange).toHaveBeenCalled();
+  });
+
+  it("renders the wrapper div with password-input-wrapper class", () => {
+    const { container } = render(<PasswordInput />);
+    expect(
+      container.querySelector(".password-input-wrapper")
+    ).toBeInTheDocument();
+  });
+});