lhcb-ntuple-wizard-test 2.1.0 → 2.2.0

package/dist/tests/components/RequestButtonGroup.test.js

@@ -0,0 +1,132 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { render, screen } from "@testing-library/react";
+import { fireEvent } from "@testing-library/react";
+import { RequestButtonGroup } from "../../components/RequestButtonGroup";
+import { createMockDtt, createMockRow } from "../testUtils";
+// ---------------------------------------------------------------------------
+// Mocks
+// ---------------------------------------------------------------------------
+const mockNavigate = vi.fn();
+vi.mock("react-router-dom", () => ({
+    useNavigate: () => mockNavigate,
+}));
+vi.mock("../../utils/utils", () => ({
+    downloadText: vi.fn(),
+    sanitizeFilename: vi.fn((s) => s),
+}));
+vi.mock("../../models/yamlFile", () => ({
+    YamlFile: {
+        createInfoYaml: vi.fn(() => ({ name: "info.yaml", content: "" })),
+    },
+}));
+vi.mock("../../components/modals/UploadDttConfigModal", () => ({
+    UploadDttConfigModal: ({ onClose }) => (_jsx("div", { "data-testid": "upload-modal", children: _jsx("button", { onClick: onClose, children: "Close" }) })),
+}));
+let mockVariant = "standalone";
+let mockBasePath = "";
+vi.mock("../../providers/WizardConfigProvider", () => ({
+    useWizardConfig: () => ({ variant: mockVariant, basePath: mockBasePath }),
+}));
+let mockValidation = { allRowsHaveDtt: true, allRowsHavePaths: true, isEmailValid: true };
+vi.mock("../../providers/RequestProvider", () => ({
+    useRequest: () => ({ validation: mockValidation }),
+}));
+const mockSetRows = vi.fn();
+let mockRows = [createMockRow({ dtt: createMockDtt() })];
+let mockConfiguredRows = mockRows;
+vi.mock("../../providers/RowsProvider", () => ({
+    useRows: () => ({
+        rows: mockRows,
+        configuredRows: mockConfiguredRows,
+        setRows: mockSetRows,
+    }),
+}));
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe("RequestButtonGroup — standalone variant", () => {
+    beforeEach(() => {
+        mockVariant = "standalone";
+        mockNavigate.mockClear();
+        mockSetRows.mockClear();
+    });
+    it("renders the Select decays button", () => {
+        render(_jsx(RequestButtonGroup, {}));
+        expect(screen.getByText(/select decays/i)).toBeInTheDocument();
+    });
+    it("renders the upload button in standalone mode", () => {
+        const { container } = render(_jsx(RequestButtonGroup, {}));
+        // Upload button is icon-only; find by aria or just count buttons
+        const buttons = container.querySelectorAll("button");
+        expect(buttons.length).toBeGreaterThanOrEqual(3); // Select + Upload + Configure + Download
+    });
+    it("renders the download button in standalone mode", () => {
+        const { container } = render(_jsx(RequestButtonGroup, {}));
+        const buttons = container.querySelectorAll("button");
+        // 4 buttons: Select decays, Upload, Configure, Download
+        expect(buttons.length).toBe(4);
+    });
+    it("navigates to select decays page on Select button click", () => {
+        render(_jsx(RequestButtonGroup, {}));
+        fireEvent.click(screen.getByText(/select decays/i));
+        expect(mockNavigate).toHaveBeenCalledWith("/select-decays");
+    });
+    it("opens UploadDttConfigModal when upload button is clicked", () => {
+        const { container } = render(_jsx(RequestButtonGroup, {}));
+        // The upload button is the second button
+        const buttons = container.querySelectorAll("button");
+        fireEvent.click(buttons[1]);
+        expect(screen.getByTestId("upload-modal")).toBeInTheDocument();
+    });
+    it("closes UploadDttConfigModal when onClose is called", () => {
+        const { container } = render(_jsx(RequestButtonGroup, {}));
+        const buttons = container.querySelectorAll("button");
+        fireEvent.click(buttons[1]);
+        expect(screen.getByTestId("upload-modal")).toBeInTheDocument();
+        fireEvent.click(screen.getByText("Close"));
+        expect(screen.queryByTestId("upload-modal")).not.toBeInTheDocument();
+    });
+    it("download button is disabled when validation fails", () => {
+        mockValidation = { allRowsHaveDtt: false, allRowsHavePaths: false, isEmailValid: false };
+        const { container } = render(_jsx(RequestButtonGroup, {}));
+        const buttons = container.querySelectorAll("button");
+        // Download button is the last one (index 3)
+        expect(buttons[3]).toBeDisabled();
+        mockValidation = { allRowsHaveDtt: true, allRowsHavePaths: true, isEmailValid: true };
+    });
+    it("configure button is disabled when not all rows have DTT", () => {
+        mockValidation = { allRowsHaveDtt: false, allRowsHavePaths: true, isEmailValid: true };
+        const { container } = render(_jsx(RequestButtonGroup, {}));
+        const buttons = container.querySelectorAll("button");
+        // Configure button is index 2 (after Select and Upload)
+        expect(buttons[2]).toBeDisabled();
+        mockValidation = { allRowsHaveDtt: true, allRowsHavePaths: true, isEmailValid: true };
+    });
+    it("clicking Configure all DTTs calls setRows and navigates", async () => {
+        // mockValidation has allRowsHaveDtt: true by default
+        const { container } = render(_jsx(RequestButtonGroup, {}));
+        const buttons = container.querySelectorAll("button");
+        // Configure button is index 2 (Select, Upload, Configure, Download)
+        fireEvent.click(buttons[2]);
+        expect(mockSetRows).toHaveBeenCalled();
+        await vi.waitFor(() => expect(mockNavigate).toHaveBeenCalledWith("/variables"));
+    });
+});
+describe("RequestButtonGroup — embedded variant", () => {
+    beforeEach(() => {
+        mockVariant = "embedded";
+        mockNavigate.mockClear();
+    });
+    it("does not render upload button in embedded mode", () => {
+        const { container } = render(_jsx(RequestButtonGroup, {}));
+        // Only Select decays + Configure (no Upload, no Download)
+        const buttons = container.querySelectorAll("button");
+        expect(buttons.length).toBe(2);
+    });
+    it("does not render download button in embedded mode", () => {
+        const { container } = render(_jsx(RequestButtonGroup, {}));
+        const buttons = container.querySelectorAll("button");
+        expect(buttons.length).toBe(2);
+    });
+});

package/dist/tests/components/RequestRow.test.d.ts

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

package/dist/tests/components/RequestRow.test.js

@@ -0,0 +1,58 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, expect, it, vi } from "vitest";
+import { render, screen } from "@testing-library/react";
+import { RequestRow } from "../../components/RequestRow";
+import { createMockRow, mockStrippingLine } from "../testUtils";
+const mockRemoveRow = vi.fn();
+vi.mock("../../providers/RowProvider", () => ({
+    useRow: () => ({
+        row: createMockRow({ line: mockStrippingLine }),
+        validateBkPath: vi.fn(() => true),
+        updateBkPaths: vi.fn(),
+    }),
+}));
+vi.mock("../../providers/RowsProvider", () => ({
+    useRows: () => ({
+        rows: [],
+        configuredRows: [],
+        setRows: vi.fn(),
+        updateRow: vi.fn(),
+        removeRow: mockRemoveRow,
+        generateAllFiles: vi.fn(),
+    }),
+}));
+// Stub all heavy sub-components
+vi.mock("../../components/DecayCard", () => ({
+    DecayCard: () => _jsx("div", { "data-testid": "decay-card" }),
+}));
+vi.mock("../../components/BookkeepingPathDropdown", () => ({
+    BookkeepingPathDropdown: () => _jsx("div", { "data-testid": "bk-dropdown" }),
+}));
+vi.mock("../../components/StrippingLineDropdown", () => ({
+    StrippingLineDropdown: () => _jsx("div", { "data-testid": "stripping-dropdown" }),
+}));
+vi.mock("../../components/StrippingLineInfoButton", () => ({
+    StrippingLineInfoButton: () => _jsx("button", { "data-testid": "info-button" }),
+}));
+vi.mock("../../components/VerticalLine", () => ({ VerticalLine: () => _jsx("div", { "data-testid": "vertical-line" }) }));
+vi.mock("../../components/DeleteButton", () => ({
+    DeleteButton: ({ action }) => (_jsx("button", { "data-testid": "delete-button", onClick: action, children: "Delete" })),
+}));
+describe("RequestRow", () => {
+    it("renders the DecayCard", () => {
+        render(_jsx(RequestRow, {}));
+        expect(screen.getByTestId("decay-card")).toBeInTheDocument();
+    });
+    it("renders the StrippingLineDropdown", () => {
+        render(_jsx(RequestRow, {}));
+        expect(screen.getByTestId("stripping-dropdown")).toBeInTheDocument();
+    });
+    it("renders the BookkeepingPathDropdown", () => {
+        render(_jsx(RequestRow, {}));
+        expect(screen.getByTestId("bk-dropdown")).toBeInTheDocument();
+    });
+    it("renders the DeleteButton", () => {
+        render(_jsx(RequestRow, {}));
+        expect(screen.getByTestId("delete-button")).toBeInTheDocument();
+    });
+});

package/dist/tests/components/StrippingLineDropdown.test.d.ts

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

package/dist/tests/components/StrippingLineDropdown.test.js

@@ -0,0 +1,88 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, expect, it, vi } from "vitest";
+import { render } from "@testing-library/react";
+import { StrippingLineDropdown } from "../../components/StrippingLineDropdown";
+import { createMockDtt, createMockRow, mockDecay, mockStrippingLine } from "../testUtils";
+const mockUpdateBkPaths = vi.fn();
+const mockUpdateRow = vi.fn();
+vi.mock("../../providers/RowProvider", () => ({
+    useRow: () => ({
+        row: { id: 0, decay: mockDecay, dtt: null, line: mockStrippingLine, paths: [], pathOptions: [] },
+        validateBkPath: vi.fn(() => true),
+        updateBkPaths: mockUpdateBkPaths,
+    }),
+}));
+vi.mock("../../providers/RowsProvider", () => ({
+    useRows: () => ({
+        rows: [],
+        configuredRows: [],
+        setRows: vi.fn(),
+        updateRow: mockUpdateRow,
+        removeRow: vi.fn(),
+        generateAllFiles: vi.fn(),
+    }),
+}));
+vi.mock("../../components/StrippingLineInfo", () => ({
+    StrippingLineInfo: () => _jsx("span", { "data-testid": "stripping-line-info" }),
+}));
+let capturedOnChange = null;
+vi.mock("react-select", () => ({
+    default: ({ onChange, placeholder }) => {
+        capturedOnChange = onChange;
+        return (_jsx("div", { className: "react-select", children: _jsx("div", { className: "control", children: _jsx("input", { role: "combobox", placeholder: placeholder }) }) }));
+    },
+}));
+describe("StrippingLineDropdown — handleStrippingLineChanged", () => {
+    it("calls updateBkPaths when a stripping line is selected", () => {
+        mockUpdateBkPaths.mockClear();
+        render(_jsx(StrippingLineDropdown, {}));
+        capturedOnChange({
+            group: "Leptonic",
+            value: "StrippingBuToKJpsiee2Line",
+            label: null,
+        });
+        expect(mockUpdateBkPaths).toHaveBeenCalled();
+    });
+    it("calls updateRow when a stripping line is selected", () => {
+        mockUpdateRow.mockClear();
+        render(_jsx(StrippingLineDropdown, {}));
+        capturedOnChange({
+            group: "Leptonic",
+            value: "StrippingBuToKJpsiee2Line",
+            label: null,
+        });
+        expect(mockUpdateRow).toHaveBeenCalled();
+    });
+    it("passes the correct line object to updateRow", () => {
+        mockUpdateRow.mockClear();
+        render(_jsx(StrippingLineDropdown, {}));
+        capturedOnChange({
+            group: "Leptonic",
+            value: "StrippingBuToKJpsiee2Line",
+            label: null,
+        });
+        // Verify the updater function builds the correct line
+        const updater = mockUpdateRow.mock.calls[0][1];
+        const result = updater(createMockRow({ line: null }));
+        expect(result.line).toEqual({
+            stream: "Leptonic",
+            line: "StrippingBuToKJpsiee2Line",
+            versions: ["28r2"],
+        });
+    });
+    it("updates dtt input when row already has a dtt", () => {
+        mockUpdateRow.mockClear();
+        render(_jsx(StrippingLineDropdown, {}));
+        capturedOnChange({
+            group: "Leptonic",
+            value: "StrippingBuToKJpsiee2Line",
+            label: null,
+        });
+        const updater = mockUpdateRow.mock.calls[0][1];
+        const mockDtt = createMockDtt("MyTree");
+        const result = updater(createMockRow({ line: null, dtt: mockDtt }));
+        // dtt.withInputFromLine should have been called, updating the input
+        expect(result.dtt).not.toBeNull();
+        expect(result.dtt?.config.input).toContain("Leptonic");
+    });
+});

package/dist/tests/components/badges.test.d.ts

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

package/dist/tests/components/badges.test.js

@@ -0,0 +1,120 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, expect, it, vi } from "vitest";
+// Restore the real module — the global mock in mockSetup.tsx is overridden here
+vi.mock("../../components/LoadingIndicator", async (importOriginal) => await importOriginal());
+import { render, screen } from "@testing-library/react";
+import { YearBadge } from "../../components/YearBadge";
+import { PolarityBadge } from "../../components/PolarityBadge";
+import { DatasetEventTypeBadge } from "../../components/DatasetEventTypeBadge";
+import { VerticalLine } from "../../components/VerticalLine";
+import { LoadingIndicator } from "../../components/LoadingIndicator";
+// ---------------------------------------------------------------------------
+// YearBadge
+// ---------------------------------------------------------------------------
+describe("YearBadge", () => {
+    it("renders the year text", () => {
+        render(_jsx(YearBadge, { year: "2016" }));
+        expect(screen.getByText("2016")).toBeInTheDocument();
+    });
+    it("applies the success background variant", () => {
+        render(_jsx(YearBadge, { year: "2018" }));
+        expect(screen.getByText("2018")).toHaveClass("bg-success");
+    });
+});
+// ---------------------------------------------------------------------------
+// PolarityBadge
+// ---------------------------------------------------------------------------
+describe("PolarityBadge", () => {
+    it("renders MagDown polarity", () => {
+        render(_jsx(PolarityBadge, { polarity: "MagDown" }));
+        expect(screen.getByText("MagDown")).toBeInTheDocument();
+    });
+    it("renders MagUp polarity", () => {
+        render(_jsx(PolarityBadge, { polarity: "MagUp" }));
+        expect(screen.getByText("MagUp")).toBeInTheDocument();
+    });
+    it("applies the danger background variant", () => {
+        render(_jsx(PolarityBadge, { polarity: "MagDown" }));
+        expect(screen.getByText("MagDown")).toHaveClass("bg-danger");
+    });
+});
+// ---------------------------------------------------------------------------
+// DatasetEventTypeBadge
+// ---------------------------------------------------------------------------
+describe("DatasetEventTypeBadge", () => {
+    it("renders 'Data' for the special event type 90000000", () => {
+        render(_jsx(DatasetEventTypeBadge, { eventType: "90000000" }));
+        expect(screen.getByText("Data")).toBeInTheDocument();
+    });
+    it("renders the raw event type code for MC event types", () => {
+        render(_jsx(DatasetEventTypeBadge, { eventType: "23103101" }));
+        expect(screen.getByText("23103101")).toBeInTheDocument();
+    });
+    it("Data badge has no link", () => {
+        const { container } = render(_jsx(DatasetEventTypeBadge, { eventType: "90000000" }));
+        // The badge renders as a span, not an anchor
+        expect(container.querySelector("a")).toBeNull();
+    });
+    it("MC event type badge links to decfiles documentation", () => {
+        const { container } = render(_jsx(DatasetEventTypeBadge, { eventType: "23103101" }));
+        const link = container.querySelector("a");
+        expect(link).not.toBeNull();
+        expect(link?.href).toContain("lhcbdoc");
+    });
+    it("applies the primary background variant", () => {
+        render(_jsx(DatasetEventTypeBadge, { eventType: "90000000" }));
+        expect(screen.getByText("Data")).toHaveClass("bg-primary");
+    });
+});
+// ---------------------------------------------------------------------------
+// VerticalLine
+// ---------------------------------------------------------------------------
+describe("VerticalLine", () => {
+    it("renders a div element", () => {
+        const { container } = render(_jsx(VerticalLine, {}));
+        expect(container.querySelector("div")).toBeInTheDocument();
+    });
+    it("applies default border-left style", () => {
+        const { container } = render(_jsx(VerticalLine, {}));
+        const div = container.querySelector("div");
+        expect(div.style.borderLeft).toContain("solid");
+    });
+    it("uses custom width when provided", () => {
+        const { container } = render(_jsx(VerticalLine, { width: "3px" }));
+        expect(container.querySelector("div").style.borderLeft).toContain("3px");
+    });
+    it("uses custom color when provided", () => {
+        const { container } = render(_jsx(VerticalLine, { color: "red" }));
+        expect(container.querySelector("div").style.borderLeft).toContain("red");
+    });
+    it("applies height style", () => {
+        const { container } = render(_jsx(VerticalLine, { height: "50px" }));
+        expect(container.querySelector("div").style.height).toBe("50px");
+    });
+});
+// ---------------------------------------------------------------------------
+// LoadingIndicator
+// ---------------------------------------------------------------------------
+describe("LoadingIndicator", () => {
+    it("renders the spinner", () => {
+        render(_jsx(LoadingIndicator, {}));
+        expect(screen.getByTestId("loading-spinner")).toBeInTheDocument();
+    });
+    it("displays the message when provided", () => {
+        render(_jsx(LoadingIndicator, { message: "Loading metadata..." }));
+        expect(screen.getByText("Loading metadata...")).toBeInTheDocument();
+    });
+    it("does not render message paragraph when no message is provided", () => {
+        render(_jsx(LoadingIndicator, {}));
+        expect(screen.queryByRole("paragraph")).not.toBeInTheDocument();
+    });
+    it("applies height style when provided", () => {
+        const { container } = render(_jsx(LoadingIndicator, { height: "200px" }));
+        const wrapper = container.firstElementChild;
+        expect(wrapper.style.height).toBe("200px");
+    });
+    it("renders spinner with status role", () => {
+        render(_jsx(LoadingIndicator, {}));
+        expect(screen.getByRole("status")).toBeInTheDocument();
+    });
+});

package/dist/tests/components/dropdowns.test.d.ts

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

package/dist/tests/components/dropdowns.test.js

@@ -0,0 +1,110 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { describe, expect, it, vi } from "vitest";
+import { render, screen } from "@testing-library/react";
+import { TagDropdown, getSelectTagOptions } from "../../components/TagDropdown";
+import { TupleToolClassDropdown } from "../../components/TupleToolClassDropdown";
+import { StrippingLineDropdown } from "../../components/StrippingLineDropdown";
+import { mockDecay, mockStrippingLine } from "../testUtils";
+// ---------------------------------------------------------------------------
+// Mocks
+// ---------------------------------------------------------------------------
+let mockSelectedBranch = [];
+vi.mock("../../providers/DttProvider", () => ({
+    useDtt: () => ({
+        selectedBranch: mockSelectedBranch,
+    }),
+}));
+vi.mock("../../config", () => ({
+    config: { disabledTupleTools: [] },
+}));
+const mockUpdateBkPaths = vi.fn();
+const mockUpdateRow = vi.fn();
+vi.mock("../../providers/RowProvider", () => ({
+    useRow: () => ({
+        row: { ...{ id: 0, decay: mockDecay, dtt: null, line: mockStrippingLine, paths: [], pathOptions: [] } },
+        validateBkPath: vi.fn(() => true),
+        updateBkPaths: mockUpdateBkPaths,
+    }),
+}));
+vi.mock("../../providers/RowsProvider", () => ({
+    useRows: () => ({
+        rows: [],
+        configuredRows: [],
+        setRows: vi.fn(),
+        updateRow: mockUpdateRow,
+        removeRow: vi.fn(),
+        generateAllFiles: vi.fn(),
+    }),
+}));
+// ---------------------------------------------------------------------------
+// getSelectTagOptions (pure function)
+// ---------------------------------------------------------------------------
+describe("getSelectTagOptions()", () => {
+    it("returns one option per tag", () => {
+        const tags = {
+            B2OC: { description: "B to OC", hide: false, warn: false },
+            SLOW: { description: "Slow", hide: false, warn: true },
+        };
+        const options = getSelectTagOptions(tags);
+        expect(options).toHaveLength(2);
+    });
+    it("filters tags based on the filter function", () => {
+        const tags = {
+            B2OC: { description: "B to OC", hide: false, warn: false },
+            SLOW: { description: "Slow", hide: false, warn: true },
+        };
+        const options = getSelectTagOptions(tags, (tag) => tag.warn);
+        expect(options).toHaveLength(1);
+        expect(options[0].value).toBe("SLOW");
+    });
+    it("maps keys to option values", () => {
+        const tags = {
+            B2OC: { description: "B to OC", hide: false, warn: false },
+        };
+        const options = getSelectTagOptions(tags);
+        expect(options[0].value).toBe("B2OC");
+    });
+    it("renders the option label JSX with the tag key as visible text", () => {
+        const tags = { B2OC: { description: "B to open charm", hide: false, warn: false } };
+        const options = getSelectTagOptions(tags);
+        render(_jsx(_Fragment, { children: options[0].label }));
+        expect(screen.getByText("B2OC")).toBeInTheDocument();
+    });
+});
+// ---------------------------------------------------------------------------
+// TagDropdown
+// ---------------------------------------------------------------------------
+describe("TagDropdown", () => {
+    it("renders a select element for decayTags", () => {
+        const { container } = render(_jsx(TagDropdown, { type: "decayTags" }));
+        // react-select renders its input element
+        expect(container.querySelector(".react-select")).toBeInTheDocument();
+    });
+    it("renders a select element for particleTags", () => {
+        const { container } = render(_jsx(TagDropdown, { type: "particleTags" }));
+        expect(container.querySelector(".react-select")).toBeInTheDocument();
+    });
+});
+// ---------------------------------------------------------------------------
+// TupleToolClassDropdown
+// ---------------------------------------------------------------------------
+describe("TupleToolClassDropdown", () => {
+    it("renders a select with placeholder", () => {
+        const { container } = render(_jsx(TupleToolClassDropdown, {}));
+        expect(container.querySelector(".react-select")).toBeInTheDocument();
+    });
+});
+// ---------------------------------------------------------------------------
+// StrippingLineDropdown
+// ---------------------------------------------------------------------------
+describe("StrippingLineDropdown", () => {
+    it("renders a select element", () => {
+        const { container } = render(_jsx(StrippingLineDropdown, {}));
+        // react-select renders a div with class 'react-select__container' or similar
+        expect(container.querySelector("[class*='control']")).toBeInTheDocument();
+    });
+    it("renders a combobox input for keyboard access", () => {
+        render(_jsx(StrippingLineDropdown, {}));
+        expect(screen.getByRole("combobox")).toBeInTheDocument();
+    });
+});

package/dist/tests/components/dttComponents.test.d.ts

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