lhcb-ntuple-wizard-test 2.1.0 → 2.2.1

package/dist/tests/pages/RequestPage.test.js

@@ -0,0 +1,439 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { RequestPage } from "../../pages/RequestPage";
+import { MemoryRouter } from "react-router-dom";
+import { createMockDtt, createMockRow, mockStrippingLine } from "../testUtils";
+import { processProductionFiles } from "../../utils/utils";
+// ---------------------------------------------------------------------------
+// Provider mocks
+// ---------------------------------------------------------------------------
+let mockRows = [];
+const mockSetRows = vi.fn();
+const mockGenerateAllFiles = vi.fn(() => []);
+vi.mock("../../providers/RowsProvider", () => ({
+    useRows: () => ({
+        rows: mockRows,
+        configuredRows: mockRows.filter((r) => r.dtt),
+        setRows: mockSetRows,
+        updateRow: vi.fn(),
+        removeRow: vi.fn(),
+        generateAllFiles: mockGenerateAllFiles,
+    }),
+}));
+let mockValidation = {
+    isEmptySession: true,
+    isEmailValid: false,
+    allRowsHaveDtt: true,
+    allRowsHaveStrippingLine: true,
+    allRowsHavePaths: true,
+    validDttNames: true,
+};
+let mockShowErrors = false;
+const mockTrySubmit = vi.fn(() => false);
+const mockClearAll = vi.fn();
+const mockSetProductionName = vi.fn();
+vi.mock("../../providers/RequestProvider", () => ({
+    useRequest: () => ({
+        emailIsKnown: false,
+        productionName: "MyProd",
+        setProductionName: mockSetProductionName,
+        validation: mockValidation,
+        showErrors: mockShowErrors,
+        clearAll: mockClearAll,
+        trySubmit: mockTrySubmit,
+        contactEmails: [],
+        setContactEmails: vi.fn(),
+        reasonForRequest: "",
+        setReasonForRequest: vi.fn(),
+    }),
+}));
+let mockVariant = "standalone";
+vi.mock("../../providers/WizardConfigProvider", () => ({
+    useWizardConfig: () => ({
+        variant: mockVariant,
+        basePath: "",
+        requestSubmittedMessage: _jsx("span", { children: "Your request has been submitted." }),
+        onRequestSubmitted: vi.fn(),
+    }),
+}));
+// ---------------------------------------------------------------------------
+// Child component mocks
+// ---------------------------------------------------------------------------
+vi.mock("../../providers/RowProvider", () => ({ RowProvider: ({ children }) => children }));
+vi.mock("../../components/RequestRow", () => ({
+    RequestRow: () => _jsx("div", { "data-testid": "request-row" }),
+}));
+vi.mock("../../components/ProductionNameInput", () => ({
+    ProductionNameInput: () => _jsx("input", { "data-testid": "production-name-input", placeholder: "Production name" }),
+}));
+vi.mock("../../components/RequestEmailInput", () => ({
+    RequestEmailInput: () => _jsx("input", { "data-testid": "email-input", placeholder: "Email" }),
+}));
+vi.mock("../../components/RequestButtonGroup", () => ({
+    RequestButtonGroup: () => _jsx("div", { "data-testid": "request-button-group" }),
+}));
+vi.mock("../../components/DeleteButton", () => ({
+    DeleteButton: ({ action, disabled, children }) => (_jsx("button", { "data-testid": "clear-all-button", onClick: action, disabled: disabled, children: children })),
+}));
+vi.mock("../../components/modals/UploadDttConfigModal", () => ({
+    UploadDttConfigModal: ({ onClose }) => (_jsx("div", { "data-testid": "upload-modal", children: _jsx("button", { onClick: onClose, children: "Close upload modal" }) })),
+}));
+vi.mock("../../components/modals/ReasonForRequestModal", () => ({
+    ReasonForRequestModal: ({ onClose }) => (_jsxs("div", { "data-testid": "reason-modal", children: [_jsx("button", { "data-testid": "reason-cancel", onClick: () => onClose(false), children: "Cancel" }), _jsx("button", { "data-testid": "reason-submit", onClick: () => onClose(true), children: "Submit" })] })),
+}));
+vi.mock("../../components/ConfigFilesUploadingAlert", () => ({
+    ConfigFilesUploadingAlert: () => _jsx("div", { "data-testid": "uploading-alert" }),
+}));
+vi.mock("../../utils/utils", async (importOriginal) => {
+    const actual = await importOriginal();
+    return { ...actual, downloadZip: vi.fn(), processProductionFiles: vi.fn(() => ({ rows: [], emails: [] })) };
+});
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function renderPage() {
+    return render(_jsx(MemoryRouter, { children: _jsx(RequestPage, {}) }));
+}
+// Wait for the useEffect to set checkedIfCloneNeeded=true, exposing the main content
+async function renderPageReady() {
+    const result = renderPage();
+    // The page renders a LoadingIndicator until its useEffect fires; wait for it to clear
+    await waitFor(() => expect(screen.queryByTestId("loading-indicator")).not.toBeInTheDocument());
+    return result;
+}
+// ---------------------------------------------------------------------------
+// Tests — initial load
+// ---------------------------------------------------------------------------
+describe("RequestPage — initial render", () => {
+    beforeEach(() => {
+        mockRows = [];
+        mockValidation = { ...mockValidation, isEmptySession: true };
+        mockShowErrors = false;
+    });
+    it("removes the loading indicator after the clone check completes", async () => {
+        await renderPageReady();
+        expect(screen.queryByTestId("loading-indicator")).not.toBeInTheDocument();
+    });
+    it("renders the production name input", async () => {
+        await renderPageReady();
+        expect(screen.getByTestId("production-name-input")).toBeInTheDocument();
+    });
+    it("renders the email input when emailIsKnown is false", async () => {
+        await renderPageReady();
+        expect(screen.getByTestId("email-input")).toBeInTheDocument();
+    });
+});
+// ---------------------------------------------------------------------------
+// Tests — standalone variant (Download button)
+// ---------------------------------------------------------------------------
+describe("RequestPage — standalone variant", () => {
+    beforeEach(() => {
+        mockRows = [];
+        mockVariant = "standalone";
+        mockShowErrors = false;
+        mockValidation = { ...mockValidation, isEmptySession: true };
+    });
+    it("renders a Download button", async () => {
+        await renderPageReady();
+        expect(screen.getByRole("button", { name: /download/i })).toBeInTheDocument();
+    });
+    it("does not render a Submit button", async () => {
+        await renderPageReady();
+        expect(screen.queryByRole("button", { name: /^submit$/i })).not.toBeInTheDocument();
+    });
+});
+// ---------------------------------------------------------------------------
+// Tests — embedded variant (Submit button)
+// ---------------------------------------------------------------------------
+describe("RequestPage — embedded variant", () => {
+    beforeEach(() => {
+        mockRows = [];
+        mockVariant = "embedded";
+        mockShowErrors = false;
+        mockValidation = { ...mockValidation, isEmptySession: true };
+    });
+    it("renders a Submit button", async () => {
+        await renderPageReady();
+        expect(screen.getByRole("button", { name: /submit/i })).toBeInTheDocument();
+    });
+    it("does not render a Download button", async () => {
+        await renderPageReady();
+        expect(screen.queryByRole("button", { name: /download/i })).not.toBeInTheDocument();
+    });
+});
+// ---------------------------------------------------------------------------
+// Tests — rows rendering
+// ---------------------------------------------------------------------------
+describe("RequestPage — rows", () => {
+    beforeEach(() => {
+        mockVariant = "standalone";
+        mockShowErrors = false;
+    });
+    it("renders no RequestRow components when there are no rows", async () => {
+        mockRows = [];
+        await renderPageReady();
+        expect(screen.queryByTestId("request-row")).not.toBeInTheDocument();
+    });
+    it("renders one RequestRow per row", async () => {
+        mockRows = [createMockRow({ id: 0 }), createMockRow({ id: 1 })];
+        await renderPageReady();
+        expect(screen.getAllByTestId("request-row")).toHaveLength(2);
+    });
+    it("shows the guide link button when there is at least one row", async () => {
+        mockRows = [createMockRow({ id: 0 })];
+        await renderPageReady();
+        expect(screen.getByTestId("guide-link")).toBeInTheDocument();
+    });
+    it("does not show the guide link button when there are no rows", async () => {
+        mockRows = [];
+        await renderPageReady();
+        expect(screen.queryByTestId("guide-link")).not.toBeInTheDocument();
+    });
+});
+// ---------------------------------------------------------------------------
+// Tests — validation error display
+// ---------------------------------------------------------------------------
+describe("RequestPage — validation errors", () => {
+    beforeEach(() => {
+        mockVariant = "standalone";
+    });
+    it("does not show an error alert before the user attempts to submit", async () => {
+        mockRows = [];
+        mockShowErrors = false;
+        await renderPageReady();
+        expect(screen.queryByRole("alert")).not.toBeInTheDocument();
+    });
+    it("shows 'Please select at least one decay' when submitted with no rows", async () => {
+        mockRows = [];
+        mockShowErrors = true;
+        await renderPageReady();
+        expect(screen.getByText(/please select at least one decay/i)).toBeInTheDocument();
+    });
+    it("shows the config error when rows exist but are missing DTT/line/paths", async () => {
+        mockRows = [createMockRow({ id: 0, dtt: null })];
+        mockShowErrors = true;
+        mockValidation = { ...mockValidation, allRowsHaveDtt: false };
+        await renderPageReady();
+        expect(screen.getByText(/please name all decaytreetuples/i)).toBeInTheDocument();
+    });
+    it("shows no error alert when all rows are fully configured", async () => {
+        const row = createMockRow({
+            id: 0,
+            dtt: createMockDtt("TreeA"),
+            line: mockStrippingLine,
+            paths: ["/some/path/DIMUON.DST"],
+        });
+        mockRows = [row];
+        mockShowErrors = false;
+        mockValidation = {
+            isEmptySession: false,
+            isEmailValid: true,
+            allRowsHaveDtt: true,
+            allRowsHaveStrippingLine: true,
+            allRowsHavePaths: true,
+            validDttNames: true,
+        };
+        await renderPageReady();
+        expect(screen.queryByRole("alert")).not.toBeInTheDocument();
+    });
+});
+// ---------------------------------------------------------------------------
+// Tests — Clear all button
+// ---------------------------------------------------------------------------
+describe("RequestPage — Clear all button", () => {
+    beforeEach(() => {
+        mockVariant = "standalone";
+        mockShowErrors = false;
+    });
+    it("is disabled when the session is empty", async () => {
+        mockRows = [];
+        mockValidation = { ...mockValidation, isEmptySession: true };
+        await renderPageReady();
+        expect(screen.getByTestId("clear-all-button")).toBeDisabled();
+    });
+    it("is enabled when the session is not empty", async () => {
+        mockRows = [createMockRow({ id: 0 })];
+        mockValidation = { ...mockValidation, isEmptySession: false };
+        await renderPageReady();
+        expect(screen.getByTestId("clear-all-button")).not.toBeDisabled();
+    });
+    it("calls clearAll when clicked", async () => {
+        mockRows = [createMockRow({ id: 0 })];
+        mockValidation = { ...mockValidation, isEmptySession: false };
+        await renderPageReady();
+        fireEvent.click(screen.getByTestId("clear-all-button"));
+        expect(mockClearAll).toHaveBeenCalledOnce();
+    });
+});
+// ---------------------------------------------------------------------------
+// Tests — primary action (Download / Submit flow)
+// ---------------------------------------------------------------------------
+describe("RequestPage — primary action", () => {
+    beforeEach(() => {
+        mockShowErrors = false;
+        mockValidation = { ...mockValidation, isEmptySession: false };
+    });
+    it("calls trySubmit when the Download button is clicked", async () => {
+        mockVariant = "standalone";
+        mockRows = [];
+        await renderPageReady();
+        fireEvent.click(screen.getByRole("button", { name: /download/i }));
+        expect(mockTrySubmit).toHaveBeenCalledOnce();
+    });
+    it("calls trySubmit when the Submit button is clicked", async () => {
+        mockVariant = "embedded";
+        mockRows = [];
+        await renderPageReady();
+        fireEvent.click(screen.getByRole("button", { name: /submit/i }));
+        expect(mockTrySubmit).toHaveBeenCalledOnce();
+    });
+    it("shows the ReasonForRequest modal when embedded variant and trySubmit returns true", async () => {
+        mockVariant = "embedded";
+        mockTrySubmit.mockReturnValueOnce(true);
+        mockRows = [];
+        await renderPageReady();
+        fireEvent.click(screen.getByRole("button", { name: /submit/i }));
+        await waitFor(() => expect(screen.getByTestId("reason-modal")).toBeInTheDocument());
+    });
+    it("shows the success alert when the reason modal is submitted", async () => {
+        mockVariant = "embedded";
+        mockTrySubmit.mockReturnValueOnce(true);
+        mockRows = [];
+        await renderPageReady();
+        fireEvent.click(screen.getByRole("button", { name: /submit/i }));
+        await waitFor(() => screen.getByTestId("reason-modal"));
+        fireEvent.click(screen.getByTestId("reason-submit"));
+        await waitFor(() => expect(screen.getByText(/request submitted/i)).toBeInTheDocument());
+    });
+    it("hides the reason modal without showing success when cancelled", async () => {
+        mockVariant = "embedded";
+        mockTrySubmit.mockReturnValueOnce(true);
+        mockRows = [];
+        await renderPageReady();
+        fireEvent.click(screen.getByRole("button", { name: /submit/i }));
+        await waitFor(() => screen.getByTestId("reason-modal"));
+        fireEvent.click(screen.getByTestId("reason-cancel"));
+        await waitFor(() => expect(screen.queryByTestId("reason-modal")).not.toBeInTheDocument());
+        expect(screen.queryByText(/request submitted/i)).not.toBeInTheDocument();
+    });
+    it("calls generateAllFiles when standalone variant and trySubmit returns true", async () => {
+        mockVariant = "standalone";
+        mockTrySubmit.mockReturnValueOnce(true);
+        mockRows = [];
+        await renderPageReady();
+        fireEvent.click(screen.getByRole("button", { name: /download/i }));
+        await waitFor(() => expect(mockGenerateAllFiles).toHaveBeenCalled());
+    });
+});
+// ---------------------------------------------------------------------------
+// Tests — success state
+// ---------------------------------------------------------------------------
+describe("RequestPage — success alert", () => {
+    it("shows the success alert and request submitted message after a successful submission", async () => {
+        mockVariant = "embedded";
+        mockTrySubmit.mockReturnValueOnce(true);
+        mockRows = [];
+        mockShowErrors = false;
+        mockValidation = { ...mockValidation, isEmptySession: false };
+        await renderPageReady();
+        fireEvent.click(screen.getByRole("button", { name: /submit/i }));
+        await waitFor(() => screen.getByTestId("reason-modal"));
+        fireEvent.click(screen.getByTestId("reason-submit"));
+        await waitFor(() => {
+            expect(screen.getByText(/request submitted!/i)).toBeInTheDocument();
+            expect(screen.getByText(/your request has been submitted/i)).toBeInTheDocument();
+        });
+    });
+    it("dismisses the success alert when its close button is clicked", async () => {
+        mockVariant = "embedded";
+        mockTrySubmit.mockReturnValueOnce(true);
+        mockRows = [];
+        await renderPageReady();
+        fireEvent.click(screen.getByRole("button", { name: /submit/i }));
+        await waitFor(() => screen.getByTestId("reason-modal"));
+        fireEvent.click(screen.getByTestId("reason-submit"));
+        await waitFor(() => screen.getByText(/request submitted!/i));
+        fireEvent.click(screen.getByLabelText(/close/i));
+        await waitFor(() => expect(screen.queryByText(/request submitted!/i)).not.toBeInTheDocument());
+    });
+});
+// ---------------------------------------------------------------------------
+// Tests — localStorage clone (lines 52-73)
+// ---------------------------------------------------------------------------
+describe("RequestPage — localStorage clone", () => {
+    beforeEach(() => {
+        mockRows = [];
+        mockVariant = "standalone";
+        mockShowErrors = false;
+        localStorage.removeItem("dttConfigsToClone");
+        localStorage.removeItem("infoYamlToClone");
+        mockSetRows.mockClear();
+        mockSetProductionName.mockClear();
+        vi.mocked(processProductionFiles).mockReturnValue({ rows: [], emails: [] });
+    });
+    it("processes dttConfigs from localStorage and calls setRows", async () => {
+        localStorage.setItem("dttConfigsToClone", JSON.stringify([]));
+        await renderPageReady();
+        expect(mockSetRows).toHaveBeenCalled();
+    });
+    it("removes the localStorage items after processing", async () => {
+        localStorage.setItem("dttConfigsToClone", JSON.stringify([]));
+        localStorage.setItem("infoYamlToClone", JSON.stringify({ production_name: "test" }));
+        await renderPageReady();
+        expect(localStorage.getItem("dttConfigsToClone")).toBeNull();
+        expect(localStorage.getItem("infoYamlToClone")).toBeNull();
+    });
+    it("calls setProductionName with empty string on success", async () => {
+        localStorage.setItem("dttConfigsToClone", JSON.stringify([]));
+        await renderPageReady();
+        expect(mockSetProductionName).toHaveBeenCalledWith("");
+    });
+    it("shows an alert and does not call setRows when processProductionFiles returns an error string", async () => {
+        vi.mocked(processProductionFiles).mockReturnValue("Something went wrong");
+        const alertSpy = vi.spyOn(window, "alert").mockImplementation(() => { });
+        localStorage.setItem("dttConfigsToClone", JSON.stringify([]));
+        renderPage();
+        await waitFor(() => expect(alertSpy).toHaveBeenCalledWith("Something went wrong"));
+        alertSpy.mockRestore();
+    });
+    it("skips the clone block when localStorage has no dttConfigsToClone", async () => {
+        await renderPageReady();
+        // setRows not called from the clone block (may be called with initial value)
+        expect(localStorage.getItem("dttConfigsToClone")).toBeNull();
+    });
+});
+// ---------------------------------------------------------------------------
+// Tests — validation error branches for allRowsHaveStrippingLine / allRowsHavePaths
+// ---------------------------------------------------------------------------
+describe("RequestPage — validation error branches (lines 140-141)", () => {
+    beforeEach(() => {
+        mockShowErrors = true;
+    });
+    it("shows error when rows exist but allRowsHaveStrippingLine=false", async () => {
+        mockRows = [createMockRow({ id: 0, dtt: createMockDtt() })];
+        mockValidation = {
+            isEmptySession: false,
+            isEmailValid: true,
+            allRowsHaveDtt: true,
+            allRowsHaveStrippingLine: false,
+            allRowsHavePaths: true,
+            validDttNames: true,
+        };
+        await renderPageReady();
+        expect(screen.getByRole("alert")).toBeInTheDocument();
+    });
+    it("shows error when rows exist but allRowsHavePaths=false", async () => {
+        mockRows = [createMockRow({ id: 0, dtt: createMockDtt() })];
+        mockValidation = {
+            isEmptySession: false,
+            isEmailValid: true,
+            allRowsHaveDtt: true,
+            allRowsHaveStrippingLine: true,
+            allRowsHavePaths: false,
+            validDttNames: true,
+        };
+        await renderPageReady();
+        expect(screen.getByRole("alert")).toBeInTheDocument();
+    });
+});

package/dist/tests/providers/DttProvider.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/providers/DttProvider.test.js

@@ -0,0 +1,105 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, expect, it, vi } from "vitest";
+import { act, renderHook } from "@testing-library/react";
+import { DttProvider, useDtt } from "../../providers/DttProvider";
+import { RowProvider } from "../../providers/RowProvider";
+import { createMockDtt, createMockRow, mockDecay, mockMetadata } from "../testUtils";
+import { TupleTool } from "../../models/tupleTool";
+import Dtt from "../../models/dtt";
+const mockUpdateRow = vi.fn();
+vi.mock("../../providers/RowsProvider", () => ({
+    useRows: () => ({
+        rows: [],
+        configuredRows: [],
+        setRows: vi.fn(),
+        updateRow: mockUpdateRow,
+        removeRow: vi.fn(),
+        generateAllFiles: vi.fn(),
+    }),
+}));
+const mockRow = createMockRow({ id: 5, dtt: createMockDtt("TestTree") });
+const mockInitialConfig = createMockDtt("TestTree").config;
+function makeWrapper() {
+    return function Wrapper({ children }) {
+        return (_jsx(RowProvider, { row: mockRow, children: _jsx(DttProvider, { initialConfig: mockInitialConfig, decay: mockDecay, metadata: mockMetadata, children: children }) }));
+    };
+}
+function renderProvider() {
+    return renderHook(() => useDtt(), { wrapper: makeWrapper() });
+}
+describe("DttProvider", () => {
+    it("exposes the initial dtt", () => {
+        const { result } = renderProvider();
+        expect(result.current.dtt).toBeInstanceOf(Dtt);
+    });
+    it("exposes the decay", () => {
+        const { result } = renderProvider();
+        expect(result.current.decay).toBe(mockDecay);
+    });
+    it("selectedBranch defaults to empty array", () => {
+        const { result } = renderProvider();
+        expect(result.current.selectedBranch).toEqual([]);
+    });
+    it("setSelectedBranch updates selectedBranch", () => {
+        const { result } = renderProvider();
+        act(() => result.current.setSelectedBranch(["head"]));
+        expect(result.current.selectedBranch).toEqual(["head"]);
+    });
+    it("hoveredBranch defaults to empty array", () => {
+        const { result } = renderProvider();
+        expect(result.current.hoveredBranch).toEqual([]);
+    });
+    it("setHoveredBranch updates hoveredBranch", () => {
+        const { result } = renderProvider();
+        act(() => result.current.setHoveredBranch(["k"]));
+        expect(result.current.hoveredBranch).toEqual(["k"]);
+    });
+    it("highlightedBranch returns hoveredBranch when it's non-empty", () => {
+        const { result } = renderProvider();
+        act(() => result.current.setSelectedBranch(["head"]));
+        act(() => result.current.setHoveredBranch(["k"]));
+        expect(result.current.highlightedBranch).toEqual(["k"]);
+    });
+    it("highlightedBranch falls back to selectedBranch when hoveredBranch is empty", () => {
+        const { result } = renderProvider();
+        act(() => result.current.setSelectedBranch(["head"]));
+        act(() => result.current.setHoveredBranch([]));
+        expect(result.current.highlightedBranch).toEqual(["head"]);
+    });
+    it("addTool adds a tool and calls updateRow", () => {
+        const { result } = renderProvider();
+        const tool = new TupleTool("TupleToolKinematic", "");
+        act(() => result.current.addTool([], tool));
+        expect(mockUpdateRow).toHaveBeenCalled();
+        expect(result.current.dtt.listTools().some((t) => t.class === "TupleToolKinematic")).toBe(true);
+    });
+    it("removeTool removes a tool and calls updateRow", () => {
+        const { result } = renderProvider();
+        const tool = new TupleTool("TupleToolKinematic", "");
+        act(() => result.current.addTool([], tool));
+        mockUpdateRow.mockClear();
+        act(() => result.current.removeTool([], tool));
+        expect(mockUpdateRow).toHaveBeenCalled();
+        expect(result.current.dtt.listTools().some((t) => t.class === "TupleToolKinematic")).toBe(false);
+    });
+    it("updateToolParam updates a param and calls updateRow", () => {
+        const { result } = renderProvider();
+        const tool = new TupleTool("TupleToolKinematic", "");
+        act(() => result.current.addTool([], tool));
+        mockUpdateRow.mockClear();
+        act(() => result.current.updateToolParam([], tool, "Verbose", true));
+        expect(mockUpdateRow).toHaveBeenCalled();
+    });
+    it("save callback creates a new Dtt instance inside updateRow", () => {
+        mockUpdateRow.mockImplementationOnce((_id, fn) => {
+            fn(mockRow);
+        });
+        const { result } = renderProvider();
+        const tool = new TupleTool("TupleToolKinematic", "");
+        act(() => result.current.addTool([], tool));
+        expect(mockUpdateRow).toHaveBeenCalled();
+    });
+    it("throws when useDtt is used outside DttProvider", () => {
+        expect(() => renderHook(() => useDtt())).toThrow("useDtt must be used inside DttProvider");
+    });
+});

package/dist/tests/providers/MetadataProvider.test.d.ts

@@ -0,0 +1 @@
+export {};