lhcb-ntuple-wizard-test 2.0.7 → 2.2.0

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

@@ -0,0 +1,213 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, expect, it, vi } from "vitest";
+import { fireEvent, render, screen } from "@testing-library/react";
+import { BoolParamInput } from "../../components/tupleToolParams/BoolParamInput";
+import { StrParamInput, sanitizeStrTupleToolParam } from "../../components/tupleToolParams/StrParamInput";
+import { NumParamInput } from "../../components/tupleToolParams/NumParamInput";
+import { ListParamInput } from "../../components/tupleToolParams/ListParamInput";
+import { DictParamInput } from "../../components/tupleToolParams/DictParamInput";
+// ---------------------------------------------------------------------------
+// BoolParamInput
+// ---------------------------------------------------------------------------
+describe("BoolParamInput", () => {
+    it("renders a toggle switch", () => {
+        render(_jsx(BoolParamInput, { value: false, onChange: vi.fn() }));
+        expect(screen.getByRole("checkbox")).toBeInTheDocument();
+    });
+    it("reflects the current value (unchecked)", () => {
+        render(_jsx(BoolParamInput, { value: false, onChange: vi.fn() }));
+        expect(screen.getByRole("checkbox")).not.toBeChecked();
+    });
+    it("reflects the current value (checked)", () => {
+        render(_jsx(BoolParamInput, { value: true, onChange: vi.fn() }));
+        expect(screen.getByRole("checkbox")).toBeChecked();
+    });
+    it("calls onChange with the toggled value when clicked", () => {
+        const onChange = vi.fn();
+        render(_jsx(BoolParamInput, { value: false, onChange: onChange }));
+        fireEvent.click(screen.getByRole("checkbox"));
+        expect(onChange).toHaveBeenCalledWith(true);
+    });
+    it("calls onChange with false when toggling from true", () => {
+        const onChange = vi.fn();
+        render(_jsx(BoolParamInput, { value: true, onChange: onChange }));
+        fireEvent.click(screen.getByRole("checkbox"));
+        expect(onChange).toHaveBeenCalledWith(false);
+    });
+});
+// ---------------------------------------------------------------------------
+// sanitizeStrTupleToolParam (exported utility)
+// ---------------------------------------------------------------------------
+describe("sanitizeStrTupleToolParam()", () => {
+    it("allows letters, numbers, underscore, colon, and hyphen", () => {
+        expect(sanitizeStrTupleToolParam("abc_123:def-xyz")).toBe("abc_123:def-xyz");
+    });
+    it("strips spaces", () => {
+        expect(sanitizeStrTupleToolParam("hello world")).toBe("helloworld");
+    });
+    it("strips special characters", () => {
+        expect(sanitizeStrTupleToolParam("a!@#b$c")).toBe("abc");
+    });
+    it("returns empty string for fully disallowed input", () => {
+        expect(sanitizeStrTupleToolParam("!@#$")).toBe("");
+    });
+});
+// ---------------------------------------------------------------------------
+// StrParamInput
+// ---------------------------------------------------------------------------
+describe("StrParamInput", () => {
+    it("renders a text input with the current value", () => {
+        render(_jsx(StrParamInput, { value: "hello", onChange: vi.fn() }));
+        expect(screen.getByDisplayValue("hello")).toBeInTheDocument();
+    });
+    it("calls onChange with the sanitized value on change", () => {
+        const onChange = vi.fn();
+        render(_jsx(StrParamInput, { value: "", onChange: onChange }));
+        fireEvent.change(screen.getByRole("textbox"), { target: { value: "valid_value" } });
+        expect(onChange).toHaveBeenCalledWith("valid_value");
+    });
+    it("strips disallowed characters except for ExtraName param", () => {
+        const onChange = vi.fn();
+        render(_jsx(StrParamInput, { value: "", onChange: onChange }));
+        fireEvent.change(screen.getByRole("textbox"), { target: { value: "hello world!" } });
+        // Space and ! are stripped by default sanitizer
+        expect(onChange).toHaveBeenCalledWith("helloworld");
+    });
+    it("allows spaces in ExtraName param (only strips non-word chars)", () => {
+        const onChange = vi.fn();
+        render(_jsx(StrParamInput, { value: "", onChange: onChange, param: "ExtraName" }));
+        fireEvent.change(screen.getByRole("textbox"), { target: { value: "My Name" } });
+        // ExtraName uses \W replacement, which also removes space
+        expect(onChange).toHaveBeenCalledWith("MyName");
+    });
+    it("shows placeholder from defaultValue", () => {
+        render(_jsx(StrParamInput, { value: "", onChange: vi.fn(), defaultValue: "default_val" }));
+        expect(screen.getByPlaceholderText("default_val")).toBeInTheDocument();
+    });
+});
+// ---------------------------------------------------------------------------
+// NumParamInput
+// ---------------------------------------------------------------------------
+describe("NumParamInput", () => {
+    it("renders a number input with the current value", () => {
+        render(_jsx(NumParamInput, { type: "int", value: 42, onChange: vi.fn() }));
+        expect(screen.getByRole("spinbutton")).toHaveValue(42);
+    });
+    it("calls onChange with the parsed number", () => {
+        const onChange = vi.fn();
+        render(_jsx(NumParamInput, { type: "float", value: 0, onChange: onChange }));
+        fireEvent.change(screen.getByRole("spinbutton"), { target: { value: "3.14" } });
+        expect(onChange).toHaveBeenCalledWith(3.14);
+    });
+    it("truncates float to int for 'int' type", () => {
+        const onChange = vi.fn();
+        render(_jsx(NumParamInput, { type: "int", value: 0, onChange: onChange }));
+        fireEvent.change(screen.getByRole("spinbutton"), { target: { value: "3.7" } });
+        expect(onChange).toHaveBeenCalledWith(3);
+    });
+    it("takes absolute value and truncates for 'uint' type", () => {
+        const onChange = vi.fn();
+        render(_jsx(NumParamInput, { type: "uint", value: 0, onChange: onChange }));
+        fireEvent.change(screen.getByRole("spinbutton"), { target: { value: "-5.9" } });
+        expect(onChange).toHaveBeenCalledWith(5);
+    });
+    it("sets min=0 for uint type", () => {
+        render(_jsx(NumParamInput, { type: "uint", value: 0, onChange: vi.fn() }));
+        expect(screen.getByRole("spinbutton")).toHaveAttribute("min", "0");
+    });
+    it("sets step=1 for int type", () => {
+        render(_jsx(NumParamInput, { type: "int", value: 0, onChange: vi.fn() }));
+        expect(screen.getByRole("spinbutton")).toHaveAttribute("step", "1");
+    });
+    it("does not set step for float type", () => {
+        render(_jsx(NumParamInput, { type: "float", value: 0, onChange: vi.fn() }));
+        expect(screen.getByRole("spinbutton")).not.toHaveAttribute("step");
+    });
+});
+// ---------------------------------------------------------------------------
+// ListParamInput
+// ---------------------------------------------------------------------------
+describe("ListParamInput", () => {
+    const strInput = ({ value, onChange, defaultValue, }) => _jsx("input", { value: value, onChange: (e) => onChange(e.target.value), placeholder: defaultValue });
+    it("renders initial items", () => {
+        render(_jsx(ListParamInput, { initialValues: ["a", "b"], defaultValues: [], newItemValue: "", onChange: vi.fn(), buildInnerInput: strInput }));
+        expect(screen.getAllByRole("textbox")).toHaveLength(2);
+    });
+    it("adds a new item when the + button is clicked", () => {
+        render(_jsx(ListParamInput, { initialValues: [], defaultValues: [], newItemValue: "new", onChange: vi.fn(), buildInnerInput: strInput }));
+        fireEvent.click(screen.getByRole("button"));
+        expect(screen.getAllByRole("textbox")).toHaveLength(1);
+    });
+    it("uses defaultValues for new items when available", () => {
+        render(_jsx(ListParamInput, { initialValues: [], defaultValues: ["default1", "default2"], newItemValue: "", onChange: vi.fn(), buildInnerInput: strInput }));
+        fireEvent.click(screen.getByRole("button"));
+        expect(screen.getByDisplayValue("default1")).toBeInTheDocument();
+    });
+    it("removes an item when its close button is clicked", () => {
+        render(_jsx(ListParamInput, { initialValues: ["a", "b"], defaultValues: [], newItemValue: "", onChange: vi.fn(), buildInnerInput: strInput }));
+        const closeButtons = screen.getAllByRole("button", { name: /close/i });
+        fireEvent.click(closeButtons[0]);
+        expect(screen.getAllByRole("textbox")).toHaveLength(1);
+    });
+    it("calls onChange when an item is removed", () => {
+        const onChange = vi.fn();
+        render(_jsx(ListParamInput, { initialValues: ["a", "b"], defaultValues: [], newItemValue: "", onChange: onChange, buildInnerInput: strInput }));
+        fireEvent.click(screen.getAllByRole("button", { name: /close/i })[0]);
+        expect(onChange).toHaveBeenCalledWith(["b"]);
+    });
+    it("calls onChange when an existing item value is changed", () => {
+        const onChange = vi.fn();
+        render(_jsx(ListParamInput, { initialValues: ["a", "b"], defaultValues: [], newItemValue: "", onChange: onChange, buildInnerInput: strInput }));
+        const inputs = screen.getAllByRole("textbox");
+        fireEvent.change(inputs[0], { target: { value: "z" } });
+        expect(onChange).toHaveBeenCalledWith(["z", "b"]);
+    });
+});
+// ---------------------------------------------------------------------------
+// DictParamInput
+// ---------------------------------------------------------------------------
+describe("DictParamInput", () => {
+    it("renders the JSON value in a textarea", () => {
+        const value = { key1: "val1" };
+        render(_jsx(DictParamInput, { value: value, onChange: vi.fn() }));
+        const textarea = screen.getByRole("textbox");
+        expect(textarea).toHaveValue(JSON.stringify(value, null, 2));
+    });
+    it("textarea is disabled by default (not in edit mode)", () => {
+        render(_jsx(DictParamInput, { value: {}, onChange: vi.fn() }));
+        expect(screen.getByRole("textbox")).toBeDisabled();
+    });
+    it("enables textarea after clicking Edit", () => {
+        render(_jsx(DictParamInput, { value: {}, onChange: vi.fn() }));
+        fireEvent.click(screen.getByText("Edit"));
+        expect(screen.getByRole("textbox")).not.toBeDisabled();
+    });
+    it("shows Save and Cancel buttons in edit mode", () => {
+        render(_jsx(DictParamInput, { value: {}, onChange: vi.fn() }));
+        fireEvent.click(screen.getByText("Edit"));
+        expect(screen.getByText("Save")).toBeInTheDocument();
+        expect(screen.getByText("Cancel")).toBeInTheDocument();
+    });
+    it("calls onChange with parsed JSON on Save", () => {
+        const onChange = vi.fn();
+        render(_jsx(DictParamInput, { value: {}, onChange: onChange }));
+        fireEvent.click(screen.getByText("Edit"));
+        fireEvent.change(screen.getByRole("textbox"), { target: { value: '{"a":"b"}' } });
+        fireEvent.click(screen.getByText("Save"));
+        expect(onChange).toHaveBeenCalledWith({ a: "b" });
+    });
+    it("shows an error alert for invalid JSON", () => {
+        render(_jsx(DictParamInput, { value: {}, onChange: vi.fn() }));
+        fireEvent.click(screen.getByText("Edit"));
+        fireEvent.change(screen.getByRole("textbox"), { target: { value: "not json" } });
+        fireEvent.click(screen.getByText("Save"));
+        expect(screen.getByText("Invalid JSON")).toBeInTheDocument();
+    });
+    it("exits edit mode and hides Save after Cancel", () => {
+        render(_jsx(DictParamInput, { value: {}, onChange: vi.fn() }));
+        fireEvent.click(screen.getByText("Edit"));
+        fireEvent.click(screen.getByText("Cancel"));
+        expect(screen.queryByText("Save")).not.toBeInTheDocument();
+        expect(screen.getByRole("textbox")).toBeDisabled();
+    });
+});

package/dist/tests/config.test.d.ts

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

package/dist/tests/config.test.js

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { config } from "../config";
+// Build a minimal ToolConfig for LoKi__Hybrid__TupleTool with the four variable dicts
+function makeLoKiConfig(variables = {}, boolVariables = {}, floatVariables = {}, intVariables = {}) {
+    const asParam = (value) => ({ value, name: "", type: "dict" });
+    return {
+        Variables: asParam(variables),
+        BoolVariables: asParam(boolVariables),
+        FloatVariables: asParam(floatVariables),
+        IntVariables: asParam(intVariables),
+    };
+}
+describe("config.tupleToolValidation — LoKi__Hybrid__TupleTool", () => {
+    const validate = config.tupleToolValidation["LoKi__Hybrid__TupleTool"].validate;
+    it("returns null when Variables has at least one entry", () => {
+        expect(validate(makeLoKiConfig({ PT: "PT" }))).toBeNull();
+    });
+    it("returns null when only BoolVariables has entries", () => {
+        expect(validate(makeLoKiConfig({}, { isPion: "ISBASIC" }))).toBeNull();
+    });
+    it("returns null when only FloatVariables has entries", () => {
+        expect(validate(makeLoKiConfig({}, {}, { mass: "M" }))).toBeNull();
+    });
+    it("returns null when only IntVariables has entries", () => {
+        expect(validate(makeLoKiConfig({}, {}, {}, { charge: "Q" }))).toBeNull();
+    });
+    it("returns an error message when all variable dicts are empty", () => {
+        const result = validate(makeLoKiConfig());
+        expect(result).toBe("Please add at least one variable");
+    });
+});

package/dist/tests/mockSetup.d.ts

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

package/dist/tests/mockSetup.js

@@ -0,0 +1,30 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { vi } from "vitest";
+import { mockMetadata } from "./testUtils";
+// ---------------------------------------------------------------------------
+// MetadataProvider — the most widely mocked module.
+// useMetadata returns the shared mockMetadata fixture.
+// MetadataProvider is stubbed as a passthrough so component tree tests work.
+// ---------------------------------------------------------------------------
+vi.mock("../providers/MetadataProvider", () => ({
+    useMetadata: () => mockMetadata,
+    MetadataProvider: ({ children }) => _jsx(_Fragment, { children: children }),
+}));
+// ---------------------------------------------------------------------------
+// react-katex — InlineMath renders as a plain span in jsdom
+// ---------------------------------------------------------------------------
+vi.mock("react-katex", () => ({
+    InlineMath: ({ math }) => _jsx("span", { "data-testid": "inline-math", children: math }),
+}));
+// ---------------------------------------------------------------------------
+// GuideLinkButton — always a simple anchor stub
+// ---------------------------------------------------------------------------
+vi.mock("../components/GuideLinkButton", () => ({
+    GuideLinkButton: () => _jsx("a", { "data-testid": "guide-link" }),
+}));
+// ---------------------------------------------------------------------------
+// LoadingIndicator — always a simple div stub
+// ---------------------------------------------------------------------------
+vi.mock("../components/LoadingIndicator", () => ({
+    LoadingIndicator: () => _jsx("div", { "data-testid": "loading-indicator" }),
+}));

package/dist/tests/models/BkPath.test.d.ts

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

package/dist/tests/models/BkPath.test.js

@@ -0,0 +1,87 @@
+import { describe, expect, it } from "vitest";
+import { BkPath } from "../../models/bkPath";
+// A valid 9-segment LHCb path (LHCb_PATH_LENGTH = 9)
+const VALID_LHCB_PATH = "/LHCb/Collision16/Beam6500GeV-VeloClosed-MagDown/Real Data/Reco16/Stripping28r2/90000000/DIMUON.DST";
+// The same path but MagUp
+const VALID_LHCB_PATH_MAGUP = "/LHCb/Collision16/Beam6500GeV-VeloClosed-MagUp/Real Data/Reco16/Stripping28r2/90000000/DIMUON.DST";
+// A valid 10-segment MC path (MC_PATH_LENGTH = 10)
+const VALID_MC_PATH = "/MC/2016/Beam6500GeV-VeloClosed-MagDown/Nu6.3-25ns-Pythia8/Sim09b/Trig0x6139160F/Stripping28r2/23103101/ALLSTREAMS.DST";
+// MC path where year is in "Collision" format
+const VALID_MC_PATH_COLLISION_YEAR = "/MC/Collision16/Beam6500GeV-VeloClosed-MagDown/Nu6.3-25ns-Pythia8/Sim09b/Trig0x6139160F/Stripping28r2/23103101/ALLSTREAMS.DST";
+describe("BkPath", () => {
+    describe("valid LHCb paths", () => {
+        it("parses the year from Collision format", () => {
+            expect(new BkPath(VALID_LHCB_PATH).year).toBe("2016");
+        });
+        it("parses the stripping version", () => {
+            expect(new BkPath(VALID_LHCB_PATH).strippingVersion).toBe("28r2");
+        });
+        it("parses MagDown polarity", () => {
+            expect(new BkPath(VALID_LHCB_PATH).polarity).toBe("MagDown");
+        });
+        it("parses MagUp polarity", () => {
+            expect(new BkPath(VALID_LHCB_PATH_MAGUP).polarity).toBe("MagUp");
+        });
+        it("parses the event type", () => {
+            expect(new BkPath(VALID_LHCB_PATH).eventType).toBe("90000000");
+        });
+        it("parses the file name", () => {
+            expect(new BkPath(VALID_LHCB_PATH).fileName).toBe("DIMUON.DST");
+        });
+    });
+    describe("valid MC paths", () => {
+        it("parses a plain year (e.g. 2016)", () => {
+            expect(new BkPath(VALID_MC_PATH).year).toBe("2016");
+        });
+        it("parses the year from Collision format in an MC path", () => {
+            expect(new BkPath(VALID_MC_PATH_COLLISION_YEAR).year).toBe("2016");
+        });
+        it("parses the stripping version", () => {
+            expect(new BkPath(VALID_MC_PATH).strippingVersion).toBe("28r2");
+        });
+        it("parses MagDown polarity from an MC path", () => {
+            expect(new BkPath(VALID_MC_PATH).polarity).toBe("MagDown");
+        });
+        it("parses the event type", () => {
+            expect(new BkPath(VALID_MC_PATH).eventType).toBe("23103101");
+        });
+        it("parses the file name", () => {
+            expect(new BkPath(VALID_MC_PATH).fileName).toBe("ALLSTREAMS.DST");
+        });
+    });
+    describe("NoPrescalingFlagged stripping version", () => {
+        it("strips NoPrescalingFlagged suffix from stripping version", () => {
+            const path = "/LHCb/Collision16/Beam6500GeV-VeloClosed-MagDown/Real Data/Reco16/Stripping28r2NoPrescalingFlagged/90000000/DIMUON.DST";
+            expect(new BkPath(path).strippingVersion).toBe("28r2");
+        });
+    });
+    describe("polarity edge cases", () => {
+        it("returns null when neither MagUp nor MagDown appears in path", () => {
+            const pathNoPolarity = "/LHCb/Collision16/Beam6500GeV-VeloClosed-NoMag/Real Data/Reco16/Stripping28r2/90000000/DIMUON.DST";
+            expect(new BkPath(pathNoPolarity).polarity).toBeNull();
+        });
+    });
+    describe("invalid paths — must throw", () => {
+        it("throws when path does not start with /", () => {
+            expect(() => new BkPath("LHCb/Collision16/Beam6500GeV-VeloClosed-MagDown/Real Data/Reco16/Stripping28r2/90000000/DIMUON.DST")).toThrow();
+        });
+        it("throws when path does not end with DST (case-insensitive)", () => {
+            expect(() => new BkPath("/LHCb/Collision16/Beam6500GeV-VeloClosed-MagDown/Real Data/Reco16/Stripping28r2/90000000/DIMUON.ROOT")).toThrow();
+        });
+        it("throws for an LHCb path with too few segments", () => {
+            expect(() => new BkPath("/LHCb/Collision16/MagDown/Stripping28r2/90000000/DIMUON.DST")).toThrow();
+        });
+        it("throws for an LHCb path with too many segments", () => {
+            expect(() => new BkPath("/LHCb/Collision16/Beam6500GeV-VeloClosed-MagDown/Real Data/Reco16/Extra/Stripping28r2/90000000/DIMUON.DST")).toThrow();
+        });
+        it("throws for an MC path with too few segments", () => {
+            expect(() => new BkPath("/MC/2016/MagDown/Stripping28r2/23103101/ALLSTREAMS.DST")).toThrow();
+        });
+        it("throws for an unrecognised type prefix", () => {
+            expect(() => new BkPath("/Other/Collision16/Beam6500GeV-VeloClosed-MagDown/Real Data/Reco16/Stripping28r2/90000000/DIMUON.DST")).toThrow();
+        });
+        it("throws for an empty string", () => {
+            expect(() => new BkPath("")).toThrow();
+        });
+    });
+});

package/dist/tests/models/Dtt.test.d.ts

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