lhcb-ntuple-wizard-test 2.1.0 → 2.2.1

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

@@ -0,0 +1,554 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { fireEvent, render, screen } from "@testing-library/react";
+import { toast } from "react-toastify";
+import { AddTupleToolModal } from "../../components/modals/AddTupleToolModal";
+import { ConfigureTupleToolModal } from "../../components/modals/ConfigureTupleToolModal";
+import { UploadDttConfigModal } from "../../components/modals/UploadDttConfigModal";
+import { ReasonForRequestModal } from "../../components/modals/ReasonForRequestModal";
+import { createMockDtt, createMockRow, mockBranchItems, mockDecay, mockToolMetadata } from "../testUtils";
+import { TupleTool } from "../../models/tupleTool";
+import Dtt from "../../models/dtt";
+import * as utils from "../../utils/utils";
+// ---------------------------------------------------------------------------
+// Shared mocks
+// ---------------------------------------------------------------------------
+const mockValidateFn = vi.fn(() => null);
+vi.mock("../../config", () => ({
+    config: {
+        disabledTupleTools: [],
+        tupleToolValidation: {
+            TupleToolKinematic: {
+                validate: () => mockValidateFn(),
+            },
+        },
+    },
+}));
+vi.mock("react-toastify", () => ({
+    toast: vi.fn(),
+}));
+const mockAddTool = vi.fn();
+const mockRemoveTool = vi.fn();
+const mockUpdateToolParam = vi.fn();
+let mockDtt = createMockDtt("MyTree");
+let mockSelectedBranch = [];
+vi.mock("../../providers/DttProvider", () => ({
+    useDtt: () => ({
+        dtt: mockDtt,
+        addTool: mockAddTool,
+        removeTool: mockRemoveTool,
+        updateToolParam: mockUpdateToolParam,
+        selectedBranch: mockSelectedBranch,
+        setSelectedBranch: vi.fn(),
+        setHoveredBranch: vi.fn(),
+        hoveredBranch: [],
+        highlightedBranch: [],
+    }),
+}));
+vi.mock("../../components/TupleToolClassDropdown", () => ({
+    TupleToolClassDropdown: ({ onChange }) => (_jsx("button", { "data-testid": "tool-class-dropdown", onClick: () => onChange({ value: "TupleToolKinematic" }), children: "Select tool" })),
+}));
+vi.mock("../../components/TupleToolDocsAccordion", () => ({
+    TupleToolDocsAccordion: () => _jsx("div", { "data-testid": "docs-accordion" }),
+}));
+vi.mock("../../components/ParticleLatex", () => ({
+    ParticleLatex: ({ particleId }) => _jsx("span", { "data-testid": `particle-${particleId}` }),
+}));
+const mockSetRows = vi.fn();
+const mockUpdateRow = vi.fn();
+const mockSetContactEmails = vi.fn();
+const mockGenerateAllFiles = vi.fn(() => []);
+// Tool metadata with diverse param types for testing ConfigureTupleToolModal switch cases
+const diverseToolMetadata = {
+    ...mockToolMetadata,
+    DiverseTool: {
+        description: "Tool with diverse param types",
+        documentation: "",
+        tags: [],
+        interface: [
+            { name: "StrParam", type: "str", cpp_type: "string", default: "hello", description: "A string param" },
+            { name: "BoolParam", type: "bool", cpp_type: "bool", default: false, description: "A bool param" },
+            { name: "IntParam", type: "int", cpp_type: "int", default: 0, description: "An int param" },
+            { name: "FloatParam", type: "float", cpp_type: "float", default: 0.0, description: "A float param" },
+            { name: "TextParam", type: "text", cpp_type: "vector<string>", default: [], description: "A text param" },
+            {
+                name: "IntListParam",
+                type: "[int]",
+                cpp_type: "vector<int>",
+                default: [],
+                description: "An int list param",
+            },
+            {
+                name: "DictParam",
+                type: "{str:str}",
+                cpp_type: "map<string,string>",
+                default: {},
+                description: "A dict param",
+            },
+            {
+                name: "DictListParam",
+                type: "{str:[str]}",
+                cpp_type: "map<string,vector<string>>",
+                default: {},
+                description: "A dict list param",
+            },
+        ],
+    },
+};
+function createDiverseDtt() {
+    return Dtt.create("[B+ -> ${head} ${k} ${mup} ${mum}]cc", mockBranchItems, [], "MyTree", diverseToolMetadata).withAddedTool(new TupleTool("DiverseTool", ""));
+}
+vi.mock("../../providers/RowsProvider", () => ({
+    useRows: () => ({
+        setRows: mockSetRows,
+        updateRow: mockUpdateRow,
+        rows: [],
+        configuredRows: [],
+        removeRow: vi.fn(),
+        generateAllFiles: mockGenerateAllFiles,
+    }),
+}));
+let mockReasonForRequest = "";
+const mockSetReasonForRequest = vi.fn();
+vi.mock("../../providers/RequestProvider", () => ({
+    useRequest: () => ({
+        setContactEmails: mockSetContactEmails,
+        productionName: "TestProduction",
+        setProductionName: vi.fn(),
+        contactEmails: [],
+        showErrors: false,
+        validation: { isEmailValid: false },
+        trySubmit: vi.fn(),
+        clearAll: vi.fn(),
+        reasonForRequest: mockReasonForRequest,
+        setReasonForRequest: mockSetReasonForRequest,
+    }),
+}));
+vi.mock("../../providers/WizardConfigProvider", () => ({
+    useWizardConfig: () => ({
+        requestReasonMessage: "Please state your reason for requesting ntuples.",
+        submitLocation: "https://example.com/api/submit",
+        variant: "embedded",
+        basePath: "/",
+    }),
+}));
+vi.mock("../../utils/utils", () => ({
+    parseProductionFiles: vi.fn(),
+    sanitizeFilename: vi.fn((s) => s),
+    downloadText: vi.fn(),
+    downloadZip: vi.fn(),
+    getControlKey: vi.fn(() => "ctrl"),
+}));
+// ---------------------------------------------------------------------------
+// AddTupleToolModal
+// ---------------------------------------------------------------------------
+describe("AddTupleToolModal", () => {
+    beforeEach(() => {
+        mockDtt = createMockDtt("MyTree");
+        mockSelectedBranch = [];
+        mockAddTool.mockClear();
+    });
+    it("renders the modal title", () => {
+        render(_jsx(AddTupleToolModal, { onClose: vi.fn() }));
+        expect(screen.getByText("Add TupleTool")).toBeInTheDocument();
+    });
+    it("renders the TupleToolClassDropdown", () => {
+        render(_jsx(AddTupleToolModal, { onClose: vi.fn() }));
+        expect(screen.getByTestId("tool-class-dropdown")).toBeInTheDocument();
+    });
+    it("calls onClose with null when Cancel is clicked", () => {
+        const onClose = vi.fn();
+        render(_jsx(AddTupleToolModal, { onClose: onClose }));
+        fireEvent.click(screen.getByText("Cancel"));
+        expect(onClose).toHaveBeenCalledWith(null);
+    });
+    it("shows the docs accordion after a tool class is selected", () => {
+        render(_jsx(AddTupleToolModal, { onClose: vi.fn() }));
+        fireEvent.click(screen.getByTestId("tool-class-dropdown"));
+        expect(screen.getByTestId("docs-accordion")).toBeInTheDocument();
+    });
+    it("Add tool button is disabled when selected tool already exists", () => {
+        // TupleToolKinematic is already in mockDtt, so button should be disabled
+        render(_jsx(AddTupleToolModal, { onClose: vi.fn() }));
+        fireEvent.click(screen.getByTestId("tool-class-dropdown"));
+        // The "Add tool" submit button should be disabled
+        const addBtn = screen
+            .getAllByText("Add tool")
+            .find((el) => el.tagName === "BUTTON" && el !== screen.getByTestId("tool-class-dropdown"));
+        expect(addBtn).toBeDisabled();
+    });
+    it("shows target particles when selectedBranch is non-empty", () => {
+        mockSelectedBranch = ["head"];
+        render(_jsx(AddTupleToolModal, { onClose: vi.fn() }));
+        expect(screen.getByTestId("particle-head")).toBeInTheDocument();
+    });
+    it("sanitizes the tool name on input and reflects the value", () => {
+        render(_jsx(AddTupleToolModal, { onClose: vi.fn() }));
+        fireEvent.click(screen.getByTestId("tool-class-dropdown"));
+        const nameInput = screen.getByPlaceholderText("TupleTool name");
+        fireEvent.change(nameInput, { target: { value: "my tool!" } });
+        expect(nameInput).toHaveValue("mytool");
+    });
+    it("pressing Enter on name input calls addTool and onClose when tool doesn't exist", () => {
+        mockDtt = createMockDtt("MyTree").withRemovedTool(new TupleTool("TupleToolKinematic", ""));
+        const onClose = vi.fn();
+        render(_jsx(AddTupleToolModal, { onClose: onClose }));
+        fireEvent.click(screen.getByTestId("tool-class-dropdown"));
+        const nameInput = screen.getByPlaceholderText("TupleTool name");
+        fireEvent.keyDown(nameInput, { key: "Enter" });
+        expect(mockAddTool).toHaveBeenCalled();
+        expect(onClose).toHaveBeenCalledWith(expect.any(TupleTool));
+    });
+    it("clicking Add tool calls addTool and onClose when tool doesn't exist", () => {
+        mockDtt = createMockDtt("MyTree").withRemovedTool(new TupleTool("TupleToolKinematic", ""));
+        const onClose = vi.fn();
+        render(_jsx(AddTupleToolModal, { onClose: onClose }));
+        fireEvent.click(screen.getByTestId("tool-class-dropdown"));
+        const addBtn = screen
+            .getAllByText("Add tool")
+            .find((el) => el.tagName === "BUTTON" && el !== screen.getByTestId("tool-class-dropdown"));
+        expect(addBtn).not.toBeDisabled();
+        fireEvent.click(addBtn);
+        expect(mockAddTool).toHaveBeenCalled();
+        expect(onClose).toHaveBeenCalledWith(expect.any(TupleTool));
+    });
+});
+// ---------------------------------------------------------------------------
+// ConfigureTupleToolModal
+// ---------------------------------------------------------------------------
+describe("ConfigureTupleToolModal", () => {
+    // Use no-name tool — matches the key "TupleToolKinematic" in mockDtt
+    const kineticTool = new TupleTool("TupleToolKinematic", "");
+    beforeEach(() => {
+        // Add TupleToolKinematic to the dtt so getToolConfig returns real config
+        mockDtt = createMockDtt("MyTree");
+        mockSelectedBranch = [];
+        mockRemoveTool.mockClear();
+        mockValidateFn.mockReturnValue(null);
+        vi.mocked(toast).mockClear();
+    });
+    it("renders the modal title with tool name", () => {
+        render(_jsx(ConfigureTupleToolModal, { tool: kineticTool, deleteIfCancelled: false, onClose: vi.fn() }));
+        expect(screen.getByText(/configure TupleToolKinematic/i)).toBeInTheDocument();
+    });
+    it("renders the docs accordion", () => {
+        render(_jsx(ConfigureTupleToolModal, { tool: kineticTool, deleteIfCancelled: false, onClose: vi.fn() }));
+        expect(screen.getByTestId("docs-accordion")).toBeInTheDocument();
+    });
+    it("calls onClose when Save & close is clicked", () => {
+        const onClose = vi.fn();
+        render(_jsx(ConfigureTupleToolModal, { tool: kineticTool, deleteIfCancelled: false, onClose: onClose }));
+        fireEvent.click(screen.getByText("Save & close"));
+        expect(onClose).toHaveBeenCalled();
+    });
+    it("calls onClose (not removeTool) on cancel when deleteIfCancelled=false", () => {
+        const onClose = vi.fn();
+        render(_jsx(ConfigureTupleToolModal, { tool: kineticTool, deleteIfCancelled: false, onClose: onClose }));
+        fireEvent.click(screen.getByText("Cancel"));
+        expect(mockRemoveTool).not.toHaveBeenCalled();
+        expect(onClose).toHaveBeenCalled();
+    });
+    it("calls removeTool on cancel when deleteIfCancelled=true", () => {
+        const onClose = vi.fn();
+        render(_jsx(ConfigureTupleToolModal, { tool: kineticTool, deleteIfCancelled: true, onClose: onClose }));
+        fireEvent.click(screen.getByText("Cancel"));
+        expect(mockRemoveTool).toHaveBeenCalled();
+        expect(onClose).toHaveBeenCalled();
+    });
+    it("calls onClose when validation passes (validate returns null)", () => {
+        mockValidateFn.mockReturnValue(null);
+        const onClose = vi.fn();
+        render(_jsx(ConfigureTupleToolModal, { tool: kineticTool, deleteIfCancelled: false, onClose: onClose }));
+        fireEvent.click(screen.getByText("Save & close"));
+        expect(onClose).toHaveBeenCalled();
+    });
+    it("shows toast error and does not close when validation fails", () => {
+        mockValidateFn.mockReturnValue("Please add at least one variable");
+        const onClose = vi.fn();
+        render(_jsx(ConfigureTupleToolModal, { tool: kineticTool, deleteIfCancelled: false, onClose: onClose }));
+        fireEvent.click(screen.getByText("Save & close"));
+        expect(toast).toHaveBeenCalledWith("Please add at least one variable", { type: "error" });
+        expect(onClose).not.toHaveBeenCalled();
+    });
+});
+describe("ConfigureTupleToolModal — diverse param types", () => {
+    beforeEach(() => {
+        mockDtt = createDiverseDtt();
+        mockSelectedBranch = [];
+        mockRemoveTool.mockClear();
+        mockValidateFn.mockReturnValue(null);
+    });
+    it("renders str param input", () => {
+        render(_jsx(ConfigureTupleToolModal, { tool: new TupleTool("DiverseTool", ""), deleteIfCancelled: false, onClose: vi.fn() }));
+        // StrParamInput renders as a text input
+        const inputs = screen.getAllByRole("textbox");
+        expect(inputs.length).toBeGreaterThan(0);
+    });
+    it("renders int param as spinbutton", () => {
+        render(_jsx(ConfigureTupleToolModal, { tool: new TupleTool("DiverseTool", ""), deleteIfCancelled: false, onClose: vi.fn() }));
+        const spinbuttons = screen.getAllByRole("spinbutton");
+        expect(spinbuttons.length).toBeGreaterThan(0);
+    });
+    it("renders [int] list param with an add button", () => {
+        render(_jsx(ConfigureTupleToolModal, { tool: new TupleTool("DiverseTool", ""), deleteIfCancelled: false, onClose: vi.fn() }));
+        // ListParamInput renders an add button
+        const buttons = screen.getAllByRole("button");
+        expect(buttons.length).toBeGreaterThan(0);
+    });
+    it("renders {str:str} dict param with an Edit button", () => {
+        render(_jsx(ConfigureTupleToolModal, { tool: new TupleTool("DiverseTool", ""), deleteIfCancelled: false, onClose: vi.fn() }));
+        expect(screen.getAllByText("Edit").length).toBeGreaterThan(0);
+    });
+    it("calls updateToolParam when str param value is changed", () => {
+        render(_jsx(ConfigureTupleToolModal, { tool: new TupleTool("DiverseTool", ""), deleteIfCancelled: false, onClose: vi.fn() }));
+        const inputs = screen.getAllByRole("textbox");
+        fireEvent.change(inputs[0], { target: { value: "new_value" } });
+        expect(mockUpdateToolParam).toHaveBeenCalled();
+    });
+    it("calls updateToolParam when bool param is toggled", () => {
+        render(_jsx(ConfigureTupleToolModal, { tool: new TupleTool("DiverseTool", ""), deleteIfCancelled: false, onClose: vi.fn() }));
+        const checkbox = screen.getByRole("checkbox");
+        fireEvent.click(checkbox);
+        expect(mockUpdateToolParam).toHaveBeenCalled();
+    });
+    it("calls updateToolParam when int param value is changed", () => {
+        render(_jsx(ConfigureTupleToolModal, { tool: new TupleTool("DiverseTool", ""), deleteIfCancelled: false, onClose: vi.fn() }));
+        const spinbuttons = screen.getAllByRole("spinbutton");
+        fireEvent.change(spinbuttons[0], { target: { value: "42" } });
+        expect(mockUpdateToolParam).toHaveBeenCalled();
+    });
+    it("calls updateToolParam when text list item is added", () => {
+        render(_jsx(ConfigureTupleToolModal, { tool: new TupleTool("DiverseTool", ""), deleteIfCancelled: false, onClose: vi.fn() }));
+        // TextParam list add button is first .btn-success
+        const addBtns = document.querySelectorAll(".btn-success");
+        expect(addBtns.length).toBeGreaterThanOrEqual(1);
+        fireEvent.click(addBtns[0]);
+        expect(mockUpdateToolParam).toHaveBeenCalled();
+    });
+    it("renders NumParamInput inside [int] list param after clicking add button", () => {
+        render(_jsx(ConfigureTupleToolModal, { tool: new TupleTool("DiverseTool", ""), deleteIfCancelled: false, onClose: vi.fn() }));
+        // Two ListParamInputs: TextParam (str list) and IntListParam (int list)
+        // Both have a .btn-success add button. The int list is the second one.
+        // Modal renders in a portal so use document-level query.
+        const addBtns = document.querySelectorAll(".btn-success");
+        expect(addBtns.length).toBeGreaterThanOrEqual(2);
+        // Click the [int] list add button (second success button)
+        fireEvent.click(addBtns[1]);
+        // After adding an item, buildInnerInput renders a NumParamInput (spinbutton)
+        expect(screen.getAllByRole("spinbutton").length).toBeGreaterThan(1);
+    });
+    it("calls updateToolParam when dict param onChange fires via Save", () => {
+        render(_jsx(ConfigureTupleToolModal, { tool: new TupleTool("DiverseTool", ""), deleteIfCancelled: false, onClose: vi.fn() }));
+        // Click the first Edit button (for DictParam)
+        fireEvent.click(screen.getAllByText("Edit")[0]);
+        // Modal renders in a portal; use document-level query for enabled textarea
+        const enabledTextarea = document.querySelector("textarea:not(:disabled)");
+        expect(enabledTextarea).not.toBeNull();
+        fireEvent.change(enabledTextarea, { target: { value: '{"k":"v"}' } });
+        fireEvent.click(screen.getByText("Save"));
+        expect(mockUpdateToolParam).toHaveBeenCalled();
+    });
+});
+// ---------------------------------------------------------------------------
+// UploadDttConfigModal
+// ---------------------------------------------------------------------------
+describe("UploadDttConfigModal", () => {
+    beforeEach(() => {
+        mockSetRows.mockClear();
+        mockSetContactEmails.mockClear();
+        vi.mocked(utils.parseProductionFiles).mockClear();
+    });
+    it("renders the modal title", () => {
+        render(_jsx(UploadDttConfigModal, { onClose: vi.fn() }));
+        expect(screen.getByText(/upload configuration file/i)).toBeInTheDocument();
+    });
+    it("renders Cancel and Import buttons", () => {
+        render(_jsx(UploadDttConfigModal, { onClose: vi.fn() }));
+        expect(screen.getByText("Cancel")).toBeInTheDocument();
+        expect(screen.getByText("Import")).toBeInTheDocument();
+    });
+    it("calls onClose when Cancel is clicked", () => {
+        const onClose = vi.fn();
+        render(_jsx(UploadDttConfigModal, { onClose: onClose }));
+        fireEvent.click(screen.getByText("Cancel"));
+        expect(onClose).toHaveBeenCalled();
+    });
+    it("calls parseProductionFiles and setRows on Import click with files", async () => {
+        vi.mocked(utils.parseProductionFiles).mockResolvedValue({ rows: [], emails: ["user@cern.ch"] });
+        const onClose = vi.fn();
+        render(_jsx(UploadDttConfigModal, { onClose: onClose }));
+        // Simulate file selection
+        const input = document.querySelector("input[type='file']");
+        const file = new File(["content"], "test.yaml", { type: "text/plain" });
+        fireEvent.change(input, { target: { files: [file] } });
+        fireEvent.click(screen.getByText("Import"));
+        // Wait for async parseProductionFiles
+        await vi.waitFor(() => expect(mockSetRows).toHaveBeenCalled());
+        expect(mockSetContactEmails).toHaveBeenCalledWith(["user@cern.ch"]);
+    });
+    it("does not call parseProductionFiles when no files are selected and Import is clicked", async () => {
+        render(_jsx(UploadDttConfigModal, { onClose: vi.fn() }));
+        fireEvent.click(screen.getByText("Import"));
+        await new Promise((r) => setTimeout(r, 20));
+        expect(vi.mocked(utils.parseProductionFiles)).not.toHaveBeenCalled();
+    });
+    it("shows alert when parseProductionFiles returns an error string", async () => {
+        vi.mocked(utils.parseProductionFiles).mockResolvedValue("Error: invalid format");
+        const alertMock = vi.spyOn(window, "alert").mockImplementation(() => { });
+        const onClose = vi.fn();
+        render(_jsx(UploadDttConfigModal, { onClose: onClose }));
+        const input = document.querySelector("input[type='file']");
+        fireEvent.change(input, { target: { files: [new File(["x"], "test.yaml")] } });
+        fireEvent.click(screen.getByText("Import"));
+        await vi.waitFor(() => expect(alertMock).toHaveBeenCalled());
+        expect(onClose).not.toHaveBeenCalled();
+        alertMock.mockRestore();
+    });
+    it("calls updateRow and onClose when currentRow template matches imported DTT", async () => {
+        const dttForImport = createMockDtt("ImportedTree");
+        const currentRow = createMockRow({
+            id: 5,
+            decay: {
+                ...mockDecay,
+                descriptors: {
+                    ...mockDecay.descriptors,
+                    template: "[B+ -> ${head} ${k} ${mup} ${mum}]cc",
+                },
+            },
+        });
+        vi.mocked(utils.parseProductionFiles).mockResolvedValue({
+            rows: [createMockRow({ dtt: dttForImport })],
+            emails: [],
+        });
+        const onClose = vi.fn();
+        render(_jsx(UploadDttConfigModal, { onClose: onClose, currentRow: currentRow }));
+        const input = document.querySelector("input[type='file']");
+        fireEvent.change(input, { target: { files: [new File(["x"], "test.yaml")] } });
+        fireEvent.click(screen.getByText("Import"));
+        await vi.waitFor(() => expect(onClose).toHaveBeenCalled());
+        expect(mockUpdateRow).toHaveBeenCalled();
+    });
+    it("updateRow callback applies imported dtt to the row", async () => {
+        const dttForImport = createMockDtt("ImportedTree");
+        const currentRow = createMockRow({
+            id: 5,
+            line: null,
+            decay: {
+                ...mockDecay,
+                descriptors: { ...mockDecay.descriptors, template: "[B+ -> ${head} ${k} ${mup} ${mum}]cc" },
+            },
+        });
+        vi.mocked(utils.parseProductionFiles).mockResolvedValue({
+            rows: [createMockRow({ dtt: dttForImport })],
+            emails: [],
+        });
+        mockUpdateRow.mockImplementationOnce((_id, fn) => {
+            fn(currentRow);
+        });
+        const onClose = vi.fn();
+        render(_jsx(UploadDttConfigModal, { onClose: onClose, currentRow: currentRow }));
+        const input = document.querySelector("input[type='file']");
+        fireEvent.change(input, { target: { files: [new File(["x"], "test.yaml")] } });
+        fireEvent.click(screen.getByText("Import"));
+        await vi.waitFor(() => expect(onClose).toHaveBeenCalled());
+    });
+    it("shows alert when currentRow template does not match imported DTT", async () => {
+        const dttForImport = createMockDtt("ImportedTree");
+        const currentRow = createMockRow({
+            id: 5,
+            decay: {
+                ...mockDecay,
+                descriptors: {
+                    ...mockDecay.descriptors,
+                    template: "COMPLETELY_DIFFERENT_TEMPLATE",
+                },
+            },
+        });
+        vi.mocked(utils.parseProductionFiles).mockResolvedValue({
+            rows: [createMockRow({ dtt: dttForImport })],
+            emails: [],
+        });
+        const alertMock = vi.spyOn(window, "alert").mockImplementation(() => { });
+        const onClose = vi.fn();
+        render(_jsx(UploadDttConfigModal, { onClose: onClose, currentRow: currentRow }));
+        const input = document.querySelector("input[type='file']");
+        fireEvent.change(input, { target: { files: [new File(["x"], "test.yaml")] } });
+        fireEvent.click(screen.getByText("Import"));
+        await vi.waitFor(() => expect(alertMock).toHaveBeenCalled());
+        expect(onClose).not.toHaveBeenCalled();
+        alertMock.mockRestore();
+    });
+});
+// ---------------------------------------------------------------------------
+// ReasonForRequestModal
+// ---------------------------------------------------------------------------
+describe("ReasonForRequestModal", () => {
+    beforeEach(() => {
+        mockReasonForRequest = "";
+        mockSetReasonForRequest.mockClear();
+        mockGenerateAllFiles.mockClear();
+        vi.stubGlobal("fetch", vi.fn(() => Promise.resolve({ ok: true })));
+    });
+    afterEach(() => {
+        vi.unstubAllGlobals();
+    });
+    it("renders the modal title", () => {
+        render(_jsx(ReasonForRequestModal, { onClose: vi.fn() }));
+        expect(screen.getAllByText("Reason for request").length).toBeGreaterThan(0);
+    });
+    it("renders the requestReasonMessage", () => {
+        render(_jsx(ReasonForRequestModal, { onClose: vi.fn() }));
+        expect(screen.getByText("Please state your reason for requesting ntuples.")).toBeInTheDocument();
+    });
+    it("Submit button is disabled when reasonForRequest is empty", () => {
+        mockReasonForRequest = "";
+        render(_jsx(ReasonForRequestModal, { onClose: vi.fn() }));
+        expect(screen.getByText("Submit request")).toBeDisabled();
+    });
+    it("Submit button is enabled when reasonForRequest is non-empty", () => {
+        mockReasonForRequest = "I need these for my thesis.";
+        render(_jsx(ReasonForRequestModal, { onClose: vi.fn() }));
+        expect(screen.getByText("Submit request")).not.toBeDisabled();
+    });
+    it("calls onClose(false) when the modal close button is clicked", () => {
+        const onClose = vi.fn();
+        render(_jsx(ReasonForRequestModal, { onClose: onClose }));
+        fireEvent.click(screen.getByLabelText("Close"));
+        expect(onClose).toHaveBeenCalledWith(false);
+    });
+    it("calls fetch and onClose(true) on successful submit", async () => {
+        mockReasonForRequest = "Research purposes";
+        const onClose = vi.fn();
+        render(_jsx(ReasonForRequestModal, { onClose: onClose }));
+        fireEvent.click(screen.getByText("Submit request"));
+        await vi.waitFor(() => expect(onClose).toHaveBeenCalledWith(true));
+    });
+    it("shows error alert on failed fetch (non-ok response)", async () => {
+        vi.stubGlobal("fetch", vi.fn(() => Promise.resolve({ ok: false, status: 500 })));
+        mockReasonForRequest = "Research purposes";
+        render(_jsx(ReasonForRequestModal, { onClose: vi.fn() }));
+        fireEvent.click(screen.getByText("Submit request"));
+        await vi.waitFor(() => expect(screen.getByText(/something went wrong while submitting/i)).toBeInTheDocument());
+    });
+    it("shows error alert when fetch rejects", async () => {
+        vi.stubGlobal("fetch", vi.fn(() => Promise.reject(new Error("Network error"))));
+        mockReasonForRequest = "Research purposes";
+        render(_jsx(ReasonForRequestModal, { onClose: vi.fn() }));
+        fireEvent.click(screen.getByText("Submit request"));
+        await vi.waitFor(() => expect(screen.getByText(/something went wrong while submitting/i)).toBeInTheDocument());
+    });
+    it("calls generateAllFiles on submit", async () => {
+        mockReasonForRequest = "Research purposes";
+        render(_jsx(ReasonForRequestModal, { onClose: vi.fn() }));
+        fireEvent.click(screen.getByText("Submit request"));
+        await vi.waitFor(() => expect(mockGenerateAllFiles).toHaveBeenCalled());
+    });
+    it("appends file contents from generateAllFiles to the FormData", async () => {
+        mockReasonForRequest = "Research purposes";
+        mockGenerateAllFiles.mockReturnValueOnce([{ name: "tree.yaml", content: "yaml: content" }]);
+        const onClose = vi.fn();
+        render(_jsx(ReasonForRequestModal, { onClose: onClose }));
+        fireEvent.click(screen.getByText("Submit request"));
+        await vi.waitFor(() => expect(onClose).toHaveBeenCalledWith(true));
+    });
+});

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

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