lhcb-ntuple-wizard-test 2.1.0 → 2.2.1

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

@@ -0,0 +1,36 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, expect, it } from "vitest";
+import { renderHook } from "@testing-library/react";
+import { WizardConfigProvider, useWizardConfig } from "../../providers/WizardConfigProvider";
+function makeWrapper(config) {
+    return function Wrapper({ children }) {
+        return (_jsx(WizardConfigProvider, { basePath: config.basePath ?? "", submitLocation: config.submitLocation, children: children }));
+    };
+}
+describe("WizardConfigProvider", () => {
+    it("sets variant to 'standalone' when no submitLocation is provided", () => {
+        const { result } = renderHook(() => useWizardConfig(), { wrapper: makeWrapper({}) });
+        expect(result.current.variant).toBe("standalone");
+    });
+    it("sets variant to 'embedded' when submitLocation is provided", () => {
+        const { result } = renderHook(() => useWizardConfig(), {
+            wrapper: makeWrapper({ submitLocation: "https://example.com/submit" }),
+        });
+        expect(result.current.variant).toBe("embedded");
+    });
+    it("exposes the basePath", () => {
+        const { result } = renderHook(() => useWizardConfig(), {
+            wrapper: makeWrapper({ basePath: "/wizard" }),
+        });
+        expect(result.current.basePath).toBe("/wizard");
+    });
+    it("exposes the submitLocation", () => {
+        const { result } = renderHook(() => useWizardConfig(), {
+            wrapper: makeWrapper({ submitLocation: "https://example.com/submit" }),
+        });
+        expect(result.current.submitLocation).toBe("https://example.com/submit");
+    });
+    it("throws when useWizardConfig is called outside the provider", () => {
+        expect(() => renderHook(() => useWizardConfig())).toThrow("useWizardConfig must be used within a WizardConfigProvider");
+    });
+});

package/dist/tests/setupTests.d.ts

@@ -0,0 +1 @@
+import "@testing-library/jest-dom/vitest";

package/dist/tests/setupTests.js

@@ -0,0 +1,15 @@
+import "@testing-library/jest-dom/vitest";
+import { afterAll, afterEach, beforeEach, vi } from "vitest";
+import { cleanup } from "@testing-library/react";
+afterAll(() => {
+    vi.restoreAllMocks();
+});
+beforeEach(() => {
+    vi.resetAllMocks();
+    localStorage.clear();
+    vi.spyOn(console, "error").mockImplementation(() => { });
+    vi.spyOn(console, "warn").mockImplementation(() => { });
+});
+afterEach(() => {
+    cleanup();
+});

package/dist/tests/testUtils.d.ts

@@ -0,0 +1,33 @@
+import { ReactNode } from "react";
+import { BranchMapItem, ToolMetadata } from "../models/dtt";
+import Dtt from "../models/dtt";
+import { DecayData } from "../models/decayData";
+import { RowData } from "../models/rowData";
+import { StrippingLine } from "../models/strippingLine";
+import { MetadataContext } from "../providers/MetadataProvider";
+import { Particle } from "../models/particle";
+export declare const mockToolMetadata: ToolMetadata;
+export declare const mockBranchItems: BranchMapItem[];
+export declare const mockDecay: DecayData;
+export declare const mockStrippingLine: StrippingLine;
+export declare const mockStrippingLinePrescaled: StrippingLine;
+export declare function createMockDtt(name?: string): Dtt;
+export declare function createMockRow(overrides?: Partial<RowData>): RowData;
+export declare const mockParticleProperties: {
+    [key: string]: Particle;
+};
+export declare const mockMetadata: MetadataContext;
+export declare const mockInlineMath: ({ math }: {
+    math: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const mockGuideLinkButton: () => import("react/jsx-runtime").JSX.Element;
+export declare const mockVerticalLine: () => import("react/jsx-runtime").JSX.Element;
+export declare const mockLoadingIndicator: () => import("react/jsx-runtime").JSX.Element;
+export declare const mockPassthrough: ({ children }: {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+interface RenderOptions {
+    initialRoute?: string;
+}
+export declare function renderWithRouter(ui: ReactNode, { initialRoute }?: RenderOptions): import("@testing-library/react").RenderResult<typeof import("@testing-library/dom/types/queries"), HTMLElement, HTMLElement>;
+export {};

package/dist/tests/testUtils.js

@@ -0,0 +1,196 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { render } from "@testing-library/react";
+import { MemoryRouter } from "react-router-dom";
+import Dtt from "../models/dtt";
+// ---------------------------------------------------------------------------
+// Shared mock tool metadata
+// ---------------------------------------------------------------------------
+export const mockToolMetadata = {
+    TupleToolKinematic: {
+        description: "Kinematic information",
+        documentation: "",
+        tags: [],
+        interface: [{ name: "Verbose", type: "bool", cpp_type: "bool", default: false, description: "Verbose output" }],
+    },
+    TupleToolPid: {
+        description: "PID information",
+        documentation: "",
+        tags: [],
+        interface: [{ name: "Verbose", type: "bool", cpp_type: "bool", default: false, description: "Verbose output" }],
+    },
+    TupleToolANNPID: {
+        description: "ANN PID",
+        documentation: "",
+        tags: [],
+        interface: [],
+    },
+    TupleToolGeometry: {
+        description: "Geometry",
+        documentation: "",
+        tags: [],
+        interface: [],
+    },
+    TupleToolEventInfo: {
+        description: "Event info",
+        documentation: "",
+        tags: [],
+        interface: [],
+    },
+    TupleToolL0Data: {
+        description: "L0 trigger data",
+        documentation: "",
+        tags: [],
+        interface: [{ name: "Verbose", type: "bool", cpp_type: "bool", default: false, description: "Verbose output" }],
+    },
+};
+// ---------------------------------------------------------------------------
+// Shared mock branch items (B+ -> K+ mu+ mu-)
+// ---------------------------------------------------------------------------
+export const mockBranchItems = [
+    { branch: "head", particle: "B+" },
+    [
+        { branch: "k", particle: "K+" },
+        { branch: "mup", particle: "mu+" },
+        { branch: "mum", particle: "mu-" },
+    ],
+];
+// ---------------------------------------------------------------------------
+// Shared mock decay data
+// ---------------------------------------------------------------------------
+export const mockDecay = {
+    descriptors: {
+        plain: "[B+ -> K+ mu+ mu-]cc",
+        latex: "B^+ \\to K^+ \\mu^+ \\mu^-",
+        // Variables appear BEFORE each particle name; ]CC (uppercase) is removed by cleanLoKiSelector
+        template: "[${head}B+ -> ${k}K+ ${mup}mu+ ${mum}mu-]CC",
+        mapped_list: mockBranchItems,
+        list: ["B+", "K+", "mu+", "mu-"],
+    },
+    lines: { "Leptonic/StrippingBuToKJpsiee2Line": ["28r2"] },
+    tags: [],
+};
+// ---------------------------------------------------------------------------
+// Shared mock stripping line
+// ---------------------------------------------------------------------------
+export const mockStrippingLine = {
+    line: "StrippingBuToKJpsiee2Line",
+    stream: "Leptonic",
+    versions: ["28r2"],
+};
+export const mockStrippingLinePrescaled = {
+    line: "StrippingPrescaledTestLine",
+    stream: "Leptonic",
+    versions: ["28r2"],
+};
+// ---------------------------------------------------------------------------
+// Helper to create a Dtt with a name set
+// ---------------------------------------------------------------------------
+export function createMockDtt(name = "MyTree") {
+    return Dtt.create("[B+ -> ${head} ${k} ${mup} ${mum}]cc", mockBranchItems, [], name, mockToolMetadata).withName(name);
+}
+// ---------------------------------------------------------------------------
+// Shared mock row data
+// ---------------------------------------------------------------------------
+export function createMockRow(overrides = {}) {
+    return {
+        id: 0,
+        decay: mockDecay,
+        dtt: null,
+        line: null,
+        paths: [],
+        pathOptions: [],
+        ...overrides,
+    };
+}
+// ---------------------------------------------------------------------------
+// Shared mock particle properties
+// ---------------------------------------------------------------------------
+function mockParticle(overrides = {}) {
+    return {
+        antiparticle: "",
+        charge: 0,
+        hide: false,
+        html: "?",
+        latex: "?",
+        mass: 0,
+        pid: 0,
+        prefix: "",
+        stable: false,
+        tags: [],
+        ...overrides,
+    };
+}
+export const mockParticleProperties = {
+    "B+": mockParticle({ latex: "B^+", html: "B+", charge: 1, pid: 521 }),
+    "B-": mockParticle({ latex: "B^-", html: "B-", charge: -1, pid: -521 }),
+    "K+": mockParticle({ latex: "K^+", html: "K+", charge: 1, pid: 321 }),
+    "K-": mockParticle({ latex: "K^-", html: "K-", charge: -1, pid: -321 }),
+    "mu+": mockParticle({ latex: "\\mu^+", html: "μ+", charge: 1, pid: -13 }),
+    "mu-": mockParticle({ latex: "\\mu^-", html: "μ-", charge: -1, pid: 13 }),
+};
+// ---------------------------------------------------------------------------
+// Shared mock MetadataContext
+// ---------------------------------------------------------------------------
+export const mockMetadata = {
+    dataset: [],
+    decays: {
+        "[B+ -> K+ mu+ mu-]cc": mockDecay,
+    },
+    embedding: {},
+    kgdoc: {},
+    lokiVariables: {
+        applicationInfo: { Analysis: "v25r1", DaVinci: "v45r7", Phys: "v26r2" },
+        lokiVariables: {},
+    },
+    particleProperties: mockParticleProperties,
+    stripping: {
+        "28r2": {
+            StrippingBuToKJpsiee2Line: {
+                full_decays: ["[B+ -> K+ J/psi(1S)]cc"],
+                output: "Particles",
+                prescale: 1,
+                stream: ["Leptonic"],
+                url: { Leptonic: "http://lhcbdoc.web.cern.ch/stripping/28r2/BuToKJpsiee2Line" },
+            },
+            StrippingPrescaledTestLine: {
+                full_decays: ["[B+ -> K+ J/psi(1S)]cc"],
+                output: "Particles",
+                prescale: 0.5,
+                stream: ["Leptonic"],
+                url: {},
+            },
+        },
+    },
+    strippingHints: {
+        "28r2": { davinci: "v40r4", description: "Stripping 28r2 (2016 data)" },
+    },
+    tupleTools: {
+        applicationInfo: { Analysis: "v25r1", DaVinci: "v45r7", Phys: "v26r2" },
+        tupleTools: mockToolMetadata,
+    },
+    userHints: {
+        decayTags: {
+            B2OC: { description: "B to open charm decay", hide: false, warn: false },
+            SLOW: { description: "Slow production", hide: false, warn: true },
+        },
+        particleTags: {
+            muon: { description: "Muon particle", group: "category", hide: false },
+            kaon: { description: "Kaon particle", group: "flavour", hide: false },
+        },
+    },
+};
+// ---------------------------------------------------------------------------
+// Shared component stubs
+//
+// Names start with "mock" so Vitest's hoisting rules allow them to be
+// referenced inside vi.mock() factory functions in any test file that imports
+// them from here.
+// ---------------------------------------------------------------------------
+export const mockInlineMath = ({ math }) => _jsx("span", { "data-testid": "inline-math", children: math });
+export const mockGuideLinkButton = () => _jsx("a", { "data-testid": "guide-link" });
+export const mockVerticalLine = () => _jsx("div", { "data-testid": "vertical-line" });
+export const mockLoadingIndicator = () => _jsx("div", { "data-testid": "loading-indicator" });
+export const mockPassthrough = ({ children }) => _jsx(_Fragment, { children: children });
+export function renderWithRouter(ui, { initialRoute = "/" } = {}) {
+    return render(_jsx(MemoryRouter, { initialEntries: [initialRoute], children: ui }));
+}

package/dist/tests/utils/latexUtils.test.d.ts

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

package/dist/tests/utils/latexUtils.test.js

@@ -0,0 +1,62 @@
+import { describe, expect, it } from "vitest";
+import { convertParticleToLatex, selectionDescriptorToLatex, LATEX_SELECTED_COLOR } from "../../utils/latexUtils";
+import { mockDecay, mockMetadata } from "../testUtils";
+describe("convertParticleToLatex()", () => {
+    it("converts the arrow token to LaTeX \\to", () => {
+        expect(convertParticleToLatex(mockMetadata, "->")).toBe("\\to");
+    });
+    it("returns the LaTeX for a known particle", () => {
+        expect(convertParticleToLatex(mockMetadata, "B+")).toBe("B^+");
+    });
+    it("wraps a selected (^-prefixed) particle in \\textcolor", () => {
+        const result = convertParticleToLatex(mockMetadata, "^B+");
+        expect(result).toContain("\\textcolor");
+        expect(result).toContain(LATEX_SELECTED_COLOR);
+        expect(result).toContain("B^+");
+    });
+    it("wraps a highlighted=true particle in \\textcolor", () => {
+        const result = convertParticleToLatex(mockMetadata, "B+", true);
+        expect(result).toContain("\\textcolor");
+        expect(result).toContain("B^+");
+    });
+    it("does NOT wrap a non-selected, non-highlighted particle in \\textcolor", () => {
+        const result = convertParticleToLatex(mockMetadata, "B+", false);
+        expect(result).not.toContain("\\textcolor");
+    });
+    it("falls back to \\text{...} for particles not in metadata", () => {
+        const result = convertParticleToLatex(mockMetadata, "UnknownParticle999");
+        expect(result).toBe("\\text{UnknownParticle999}");
+    });
+    it("handles opening-parenthesis sub-decay prefix", () => {
+        const result = convertParticleToLatex(mockMetadata, "(K+");
+        expect(result.startsWith("(")).toBe(true);
+        expect(result).toContain("K^+");
+    });
+    it("handles closing-parenthesis sub-decay suffix", () => {
+        const result = convertParticleToLatex(mockMetadata, "K+)");
+        expect(result.endsWith(")")).toBe(true);
+        expect(result).toContain("K^+");
+    });
+});
+describe("selectionDescriptorToLatex()", () => {
+    it("returns a LaTeX string containing at least one particle symbol", () => {
+        const result = selectionDescriptorToLatex(mockMetadata, mockDecay, []);
+        expect(result.length).toBeGreaterThan(0);
+    });
+    it("highlights selected branches with \\textcolor", () => {
+        const result = selectionDescriptorToLatex(mockMetadata, mockDecay, ["head"]);
+        expect(result).toContain("\\textcolor");
+    });
+    it("does NOT highlight branches that are not selected", () => {
+        // Select only 'head'; 'k' should not be coloured
+        const result = selectionDescriptorToLatex(mockMetadata, mockDecay, ["head"]);
+        // K^+ should appear but not wrapped in textcolor
+        // Simplistic check: there's exactly one textcolor entry for B+
+        const colorCount = (result.match(/\\textcolor/g) || []).length;
+        expect(colorCount).toBe(1);
+    });
+    it("includes the arrow token as \\to", () => {
+        const result = selectionDescriptorToLatex(mockMetadata, mockDecay, []);
+        expect(result).toContain("\\to");
+    });
+});

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

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