lhcb-ntuple-wizard-test 2.1.0 → 2.2.0

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

@@ -0,0 +1,119 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { fireEvent, render, screen } from "@testing-library/react";
+import { DecayTreeCard } from "../../components/DecayTreeCard";
+import { mockDecay } from "../testUtils";
+// Mutable state — read at render time by the useDtt factory closure
+let mockSelectedBranch = [];
+let mockHoveredBranch = [];
+let mockDttDecay = mockDecay;
+const mockSetSelectedBranch = vi.fn();
+vi.mock("../../providers/DttProvider", () => ({
+    useDtt: () => ({
+        dtt: { getName: () => "MyTree", config: { input: "/Leptonic/StrippingBuToKJpsiee2Line" } },
+        decay: mockDttDecay,
+        selectedBranch: mockSelectedBranch,
+        setSelectedBranch: mockSetSelectedBranch,
+        hoveredBranch: mockHoveredBranch,
+        highlightedBranch: mockHoveredBranch.length > 0 ? mockHoveredBranch : mockSelectedBranch,
+        setHoveredBranch: vi.fn(),
+        updateToolParam: vi.fn(),
+        addTool: vi.fn(),
+        removeTool: vi.fn(),
+    }),
+}));
+vi.mock("../../components/DecayTagBadge", () => ({
+    DecayTagBadge: ({ tag }) => _jsx("span", { "data-testid": `tag-badge-${tag}`, children: tag }),
+}));
+vi.mock("../../components/DecayLatex", () => ({
+    DecayLatex: ({ selection }) => (_jsx("span", { "data-testid": "decay-latex", "data-selection": selection.join(",") })),
+}));
+vi.mock("../../components/DecayTreeGraph", () => ({
+    DecayTreeGraph: () => _jsx("div", { "data-testid": "decay-tree-graph" }),
+}));
+vi.mock("../../components/DecayTreeCardHeader", () => ({
+    DecayTreeCardHeader: ({ dttName }) => _jsx("div", { "data-testid": "decay-tree-card-header", children: dttName }),
+}));
+vi.mock("../../components/ParticleTagFilters", () => ({
+    ParticleTagFilters: () => _jsx("div", { "data-testid": "particle-tag-filters" }),
+}));
+vi.mock("../../components/TupleToolsAccordion", () => ({
+    TupleToolsAccordion: () => _jsx("div", { "data-testid": "tuple-tools-accordion" }),
+}));
+vi.mock("../../components/TupleToolGroupsAccordion", () => ({
+    TupleToolGroupsAccordion: () => _jsx("div", { "data-testid": "tuple-tool-groups-accordion" }),
+}));
+beforeEach(() => {
+    mockSelectedBranch = [];
+    mockHoveredBranch = [];
+    mockDttDecay = mockDecay;
+    mockSetSelectedBranch.mockClear();
+});
+describe("DecayTreeCard — particle selection count", () => {
+    it("shows '0 particles selected' (plural) when nothing is selected", () => {
+        render(_jsx(DecayTreeCard, {}));
+        expect(screen.getByText(/0 particles selected/i)).toBeInTheDocument();
+    });
+    it("shows '1 particle selected' (singular) when one branch is selected", () => {
+        mockSelectedBranch = ["head"];
+        render(_jsx(DecayTreeCard, {}));
+        expect(screen.getByText(/1 particle selected/i)).toBeInTheDocument();
+    });
+    it("shows '2 particles selected' (plural) when two branches are selected", () => {
+        mockSelectedBranch = ["head", "k"];
+        render(_jsx(DecayTreeCard, {}));
+        expect(screen.getByText(/2 particles selected/i)).toBeInTheDocument();
+    });
+});
+describe("DecayTreeCard — Deselect button", () => {
+    it("is disabled when nothing is selected", () => {
+        render(_jsx(DecayTreeCard, {}));
+        const btn = screen.getByRole("button", { name: /deselect/i });
+        expect(btn).toBeDisabled();
+    });
+    it("is enabled when a branch is selected", () => {
+        mockSelectedBranch = ["head"];
+        render(_jsx(DecayTreeCard, {}));
+        const btn = screen.getByRole("button", { name: /deselect/i });
+        expect(btn).not.toBeDisabled();
+    });
+    it("calls setSelectedBranch([]) when the Deselect button is clicked", () => {
+        mockSelectedBranch = ["head"];
+        render(_jsx(DecayTreeCard, {}));
+        fireEvent.click(screen.getByRole("button", { name: /deselect/i }));
+        expect(mockSetSelectedBranch).toHaveBeenCalledWith([]);
+    });
+});
+describe("DecayTreeCard — DecayLatex selection prop", () => {
+    it("passes hoveredBranch as selection when nothing is selected", () => {
+        mockHoveredBranch = ["k"];
+        render(_jsx(DecayTreeCard, {}));
+        const el = screen.getByTestId("decay-latex");
+        expect(el.dataset.selection).toBe("k");
+    });
+    it("passes selectedBranch as selection when a branch is selected", () => {
+        mockSelectedBranch = ["head"];
+        mockHoveredBranch = ["k"];
+        render(_jsx(DecayTreeCard, {}));
+        const el = screen.getByTestId("decay-latex");
+        expect(el.dataset.selection).toBe("head");
+    });
+});
+describe("DecayTreeCard — decay tag badges", () => {
+    it("renders a DecayTagBadge for tags with warn=true", () => {
+        // mockMetadata.userHints.decayTags has SLOW with warn=true
+        mockDttDecay = { ...mockDecay, tags: ["SLOW"] };
+        render(_jsx(DecayTreeCard, {}));
+        expect(screen.getByTestId("tag-badge-SLOW")).toBeInTheDocument();
+    });
+    it("does not render a DecayTagBadge for tags with warn=false", () => {
+        // B2OC has warn=false in mockMetadata
+        mockDttDecay = { ...mockDecay, tags: ["B2OC"] };
+        render(_jsx(DecayTreeCard, {}));
+        expect(screen.queryByTestId("tag-badge-B2OC")).not.toBeInTheDocument();
+    });
+    it("does not render any badges when decay has no tags", () => {
+        render(_jsx(DecayTreeCard, {}));
+        expect(screen.queryByTestId(/tag-badge/)).not.toBeInTheDocument();
+    });
+});

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

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

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

@@ -0,0 +1,125 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import { render } from "@testing-library/react";
+import { DecayTreeGraph } from "../../components/DecayTreeGraph";
+import { mockDecay } from "../testUtils";
+import { LATEX_SELECTED_COLOR } from "../../utils/latexUtils";
+// Mutable state — read at render time by the useDtt factory closure
+let mockSelectedBranch = [];
+let mockHighlightedBranch = [];
+let capturedElements = [];
+// Stub dtt — vi.fn() methods let individual tests override return values
+const mockDttGraph = {
+    getBranchTools: vi.fn(() => []),
+    getGroupsThatIncludeBranch: vi.fn(() => []),
+};
+vi.mock("../../providers/DttProvider", () => ({
+    useDtt: () => ({
+        dtt: mockDttGraph,
+        decay: mockDecay,
+        selectedBranch: mockSelectedBranch,
+        highlightedBranch: mockHighlightedBranch,
+        setSelectedBranch: vi.fn(),
+        hoveredBranch: [],
+        setHoveredBranch: vi.fn(),
+        updateToolParam: vi.fn(),
+        addTool: vi.fn(),
+        removeTool: vi.fn(),
+    }),
+}));
+vi.mock("react-cytoscapejs", () => ({
+    default: ({ elements }) => {
+        capturedElements = elements;
+        return _jsx("div", { "data-testid": "cytoscape" });
+    },
+}));
+// Prevent cytoscape.use(dagre) at module-top from throwing
+vi.mock("cytoscape", () => ({
+    default: Object.assign(vi.fn(), { use: vi.fn() }),
+}));
+vi.mock("cytoscape-dagre", () => ({ default: {} }));
+// tex2svg is used to generate SVG labels for graph nodes; include "currentColor" so color
+// substitution in makeSVG is visible in the imageSrc output
+vi.mock("../../utils/mathjaxUtils", () => ({
+    tex2svg: () => ({ innerHTML: "<text fill='currentColor'>x</text>" }),
+}));
+beforeEach(() => {
+    mockSelectedBranch = [];
+    mockHighlightedBranch = [];
+    capturedElements = [];
+    mockDttGraph.getBranchTools.mockReturnValue([]);
+    mockDttGraph.getGroupsThatIncludeBranch.mockReturnValue([]);
+});
+describe("DecayTreeGraph — rendering", () => {
+    it("renders the cytoscape component", () => {
+        const { getByTestId } = render(_jsx(DecayTreeGraph, { onNodeSelectionChanged: vi.fn() }));
+        expect(getByTestId("cytoscape")).toBeInTheDocument();
+    });
+});
+describe("DecayTreeGraph — buildElements", () => {
+    it("creates one node per particle in the decay", () => {
+        // mockDecay has B+, K+, mu+, mu- → 4 nodes
+        render(_jsx(DecayTreeGraph, { onNodeSelectionChanged: vi.fn() }));
+        const nodes = capturedElements.filter((e) => !e.data.source);
+        expect(nodes).toHaveLength(4);
+    });
+    it("creates one edge per parent-child relationship", () => {
+        // B+ → K+, mu+, mu- gives 3 edges
+        render(_jsx(DecayTreeGraph, { onNodeSelectionChanged: vi.fn() }));
+        const edges = capturedElements.filter((e) => e.data.source);
+        expect(edges).toHaveLength(3);
+    });
+    it("assigns the correct node ids from branch names", () => {
+        render(_jsx(DecayTreeGraph, { onNodeSelectionChanged: vi.fn() }));
+        const nodeIds = capturedElements.filter((e) => !e.data.source).map((e) => e.data.id);
+        expect(nodeIds).toEqual(expect.arrayContaining(["head", "k", "mup", "mum"]));
+    });
+    it("creates edges from head to each daughter", () => {
+        render(_jsx(DecayTreeGraph, { onNodeSelectionChanged: vi.fn() }));
+        const edges = capturedElements.filter((e) => e.data.source);
+        const edgePairs = edges.map((e) => `${e.data.source}->${e.data.target}`);
+        expect(edgePairs).toEqual(expect.arrayContaining(["head->k", "head->mup", "head->mum"]));
+    });
+    it("marks selected nodes with selected=true", () => {
+        mockSelectedBranch = ["head"];
+        render(_jsx(DecayTreeGraph, { onNodeSelectionChanged: vi.fn() }));
+        const headNode = capturedElements.find((e) => e.data.id === "head");
+        expect(headNode?.selected).toBe(true);
+    });
+    it("marks non-selected nodes with selected=false", () => {
+        mockSelectedBranch = ["head"];
+        render(_jsx(DecayTreeGraph, { onNodeSelectionChanged: vi.fn() }));
+        const kNode = capturedElements.find((e) => e.data.id === "k");
+        expect(kNode?.selected).toBe(false);
+    });
+    it("uses LATEX_SELECTED_COLOR in imageSrc for highlighted branches", () => {
+        mockHighlightedBranch = ["head"];
+        render(_jsx(DecayTreeGraph, { onNodeSelectionChanged: vi.fn() }));
+        const headNode = capturedElements.find((e) => e.data.id === "head");
+        expect(headNode?.data.imageSrc).toContain(encodeURIComponent(LATEX_SELECTED_COLOR));
+    });
+    it("uses black color in imageSrc for non-highlighted branches", () => {
+        mockHighlightedBranch = ["head"];
+        render(_jsx(DecayTreeGraph, { onNodeSelectionChanged: vi.fn() }));
+        const kNode = capturedElements.find((e) => e.data.id === "k");
+        expect(kNode?.data.imageSrc).toContain(encodeURIComponent("black"));
+    });
+    it("shows grey tupleToolStatusColor when the branch has no tools", () => {
+        render(_jsx(DecayTreeGraph, { onNodeSelectionChanged: vi.fn() }));
+        const headNode = capturedElements.find((e) => e.data.id === "head");
+        expect(headNode?.data.tupleToolStatusColor).toBe("#6c757d");
+    });
+    it("shows green tupleToolStatusColor when the branch has tools", () => {
+        // Override getBranchTools to return a non-empty array for this test
+        mockDttGraph.getBranchTools.mockReturnValue([{}]);
+        render(_jsx(DecayTreeGraph, { onNodeSelectionChanged: vi.fn() }));
+        const headNode = capturedElements.find((e) => e.data.id === "head");
+        expect(headNode?.data.tupleToolStatusColor).toBe("#198754");
+    });
+    it("shows green tupleToolStatusColor when the branch belongs to a group with tools", () => {
+        mockDttGraph.getGroupsThatIncludeBranch.mockReturnValue([{}]);
+        render(_jsx(DecayTreeGraph, { onNodeSelectionChanged: vi.fn() }));
+        const headNode = capturedElements.find((e) => e.data.id === "head");
+        expect(headNode?.data.tupleToolStatusColor).toBe("#198754");
+    });
+});

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

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

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

@@ -0,0 +1,45 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, expect, it, vi } from "vitest";
+import { fireEvent, render, screen } from "@testing-library/react";
+import { DeleteButton } from "../../components/DeleteButton";
+describe("DeleteButton", () => {
+    it("renders the trash icon button", () => {
+        render(_jsx(DeleteButton, { action: vi.fn() }));
+        expect(screen.getByRole("button")).toBeInTheDocument();
+    });
+    it("renders null when disabled", () => {
+        const { container } = render(_jsx(DeleteButton, { action: vi.fn(), disabled: true }));
+        expect(container).toBeEmptyDOMElement();
+    });
+    it("shows the popover with the default confirm message when clicked", async () => {
+        render(_jsx(DeleteButton, { action: vi.fn() }));
+        fireEvent.click(screen.getByRole("button"));
+        // The popover body containing the confirm button should appear
+        expect(await screen.findByText("Confirm")).toBeInTheDocument();
+    });
+    it("shows a custom popup message in the popover", async () => {
+        render(_jsx(DeleteButton, { action: vi.fn(), popupMessage: "Delete DecayTreeTuple" }));
+        fireEvent.click(screen.getByRole("button"));
+        expect(await screen.findByText("Delete DecayTreeTuple")).toBeInTheDocument();
+    });
+    it("calls the action callback when the confirm button is clicked", async () => {
+        const action = vi.fn();
+        render(_jsx(DeleteButton, { action: action, popupMessage: "Confirm Delete" }));
+        fireEvent.click(screen.getByRole("button"));
+        const confirmButton = await screen.findByText("Confirm Delete");
+        fireEvent.click(confirmButton);
+        expect(action).toHaveBeenCalledOnce();
+    });
+    it("renders children inside the trigger button", () => {
+        render(_jsx(DeleteButton, { action: vi.fn(), children: "Remove item" }));
+        expect(screen.getByText("Remove item")).toBeInTheDocument();
+    });
+    it("applies outline-danger variant when outline prop is set", () => {
+        render(_jsx(DeleteButton, { action: vi.fn(), outline: true }));
+        expect(screen.getByRole("button")).toHaveClass("btn-outline-danger");
+    });
+    it("applies danger variant by default (no outline prop)", () => {
+        render(_jsx(DeleteButton, { action: vi.fn() }));
+        expect(screen.getByRole("button")).toHaveClass("btn-danger");
+    });
+});

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

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

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

@@ -0,0 +1,75 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, expect, it, vi } from "vitest";
+import { fireEvent, render, screen } from "@testing-library/react";
+import { DttNameInput } from "../../components/DttNameInput";
+import { createMockDtt, createMockRow } from "../testUtils";
+const mockUpdateRow = vi.fn();
+vi.mock("../../providers/RowsProvider", () => ({
+    useRows: () => ({
+        rows: [createMockRow({ id: 0, dtt: createMockDtt("MyTree") })],
+        updateRow: mockUpdateRow,
+        configuredRows: [],
+        setRows: vi.fn(),
+        removeRow: vi.fn(),
+        generateAllFiles: vi.fn(),
+    }),
+}));
+function renderInput(name = "MyTree", onNameValidated = vi.fn()) {
+    const dtt = createMockDtt(name);
+    return render(_jsx(DttNameInput, { dtt: dtt, rowId: 0, onNameValidated: onNameValidated }));
+}
+describe("DttNameInput", () => {
+    it("renders an input with the current DTT name", () => {
+        renderInput("MyTree");
+        expect(screen.getByDisplayValue("MyTree")).toBeInTheDocument();
+    });
+    it("accepts typing a new name", () => {
+        renderInput("MyTree");
+        const input = screen.getByDisplayValue("MyTree");
+        fireEvent.change(input, { target: { value: "NewTree" } });
+        expect(screen.getByDisplayValue("NewTree")).toBeInTheDocument();
+    });
+    it("calls onNameValidated(true) when a valid name is blurred", () => {
+        const onNameValidated = vi.fn();
+        renderInput("MyTree", onNameValidated);
+        const input = screen.getByDisplayValue("MyTree");
+        fireEvent.blur(input);
+        expect(onNameValidated).toHaveBeenCalledWith(true);
+    });
+    it("calls onNameValidated(false) when the name is emptied and blurred", () => {
+        const onNameValidated = vi.fn();
+        renderInput("MyTree", onNameValidated);
+        const input = screen.getByDisplayValue("MyTree");
+        fireEvent.change(input, { target: { value: "" } });
+        fireEvent.blur(input);
+        expect(onNameValidated).toHaveBeenCalledWith(false);
+    });
+    it("shows 'Name cannot be empty' feedback when name is cleared", () => {
+        renderInput("MyTree");
+        const input = screen.getByDisplayValue("MyTree");
+        fireEvent.change(input, { target: { value: "" } });
+        fireEvent.blur(input);
+        expect(screen.getByText(/name cannot be empty/i)).toBeInTheDocument();
+    });
+    it("shows 'Name contains invalid characters' feedback for bad chars", () => {
+        renderInput("MyTree");
+        const input = screen.getByDisplayValue("MyTree");
+        fireEvent.change(input, { target: { value: "My Tree!" } });
+        fireEvent.blur(input);
+        expect(screen.getByText(/name contains invalid characters/i)).toBeInTheDocument();
+    });
+    it("calls updateRow with the new name on a valid blur", () => {
+        renderInput("MyTree");
+        const input = screen.getByDisplayValue("MyTree");
+        fireEvent.change(input, { target: { value: "ValidName" } });
+        fireEvent.blur(input);
+        expect(mockUpdateRow).toHaveBeenCalledOnce();
+    });
+    it("does NOT call updateRow when the name is invalid on blur", () => {
+        renderInput("MyTree");
+        const input = screen.getByDisplayValue("MyTree");
+        fireEvent.change(input, { target: { value: "" } });
+        fireEvent.blur(input);
+        expect(mockUpdateRow).not.toHaveBeenCalled();
+    });
+});

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

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

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

@@ -0,0 +1,57 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, expect, it, vi } from "vitest";
+import { render, screen } from "@testing-library/react";
+import { MemoryRouter } from "react-router-dom";
+import { NtupleWizard } from "../../components/NtupleWizard";
+// Stub all providers to pass children through
+vi.mock("../../providers/WizardConfigProvider", () => ({
+    WizardConfigProvider: ({ children }) => children,
+}));
+vi.mock("../../providers/RowsProvider", () => ({
+    RowsProvider: ({ children }) => children,
+}));
+vi.mock("../../providers/RequestProvider", () => ({
+    RequestProvider: ({ children }) => children,
+}));
+// Stub pages
+vi.mock("../../pages/DecaySearchPage", () => ({
+    DecaySearchPage: () => _jsx("div", { "data-testid": "decay-search-page" }),
+}));
+vi.mock("../../pages/DecayTreeConfigPage", () => ({
+    DecayTreeConfigPage: () => _jsx("div", { "data-testid": "decay-tree-config-page" }),
+}));
+vi.mock("../../pages/RequestPage", () => ({
+    RequestPage: () => _jsx("div", { "data-testid": "request-page" }),
+}));
+function renderWizard(path, props = {}) {
+    return render(_jsx(MemoryRouter, { initialEntries: [path], children: _jsx(NtupleWizard, { ...props }) }));
+}
+describe("NtupleWizard — routing", () => {
+    it("renders DecaySearchPage when pathname ends with /select-decays", () => {
+        renderWizard("/select-decays");
+        expect(screen.getByTestId("decay-search-page")).toBeInTheDocument();
+    });
+    it("renders DecayTreeConfigPage when pathname ends with /variables", () => {
+        renderWizard("/variables");
+        expect(screen.getByTestId("decay-tree-config-page")).toBeInTheDocument();
+    });
+    it("renders RequestPage for the root path", () => {
+        renderWizard("/");
+        expect(screen.getByTestId("request-page")).toBeInTheDocument();
+    });
+    it("renders RequestPage for any other path", () => {
+        renderWizard("/some-other-path");
+        expect(screen.getByTestId("request-page")).toBeInTheDocument();
+    });
+});
+describe("NtupleWizard — contactEmail", () => {
+    it("sets localStorage email when contactEmail is provided", () => {
+        renderWizard("/", { contactEmail: "test@example.com" });
+        expect(localStorage.getItem("email")).toBe("test@example.com");
+    });
+    it("does not set localStorage email when contactEmail is not provided", () => {
+        localStorage.removeItem("email");
+        renderWizard("/");
+        expect(localStorage.getItem("email")).toBeNull();
+    });
+});

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

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

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

@@ -0,0 +1,23 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, expect, it } from "vitest";
+import { render, screen } from "@testing-library/react";
+import { ParticleDropdown } from "../../components/ParticleDropdown";
+describe("ParticleDropdown", () => {
+    it("renders a combobox", () => {
+        render(_jsx(ParticleDropdown, {}));
+        expect(screen.getByRole("combobox")).toBeInTheDocument();
+    });
+    it("renders with a placeholder", () => {
+        render(_jsx(ParticleDropdown, { placeholder: "Choose particle" }));
+        expect(screen.getByText("Choose particle")).toBeInTheDocument();
+    });
+    it("renders without error in onlyHeads mode", () => {
+        expect(() => render(_jsx(ParticleDropdown, { onlyHeads: true }))).not.toThrow();
+    });
+    it("renders without error in onlyKnown mode", () => {
+        expect(() => render(_jsx(ParticleDropdown, { onlyKnown: true }))).not.toThrow();
+    });
+    it("renders without error in default mode (all particles)", () => {
+        expect(() => render(_jsx(ParticleDropdown, {}))).not.toThrow();
+    });
+});

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

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

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

@@ -0,0 +1,87 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { fireEvent, render, screen } from "@testing-library/react";
+import { ParticleTagFilters } from "../../components/ParticleTagFilters";
+import { createMockDtt, mockMetadata } from "../testUtils";
+// Custom metadata where particles have tags so filters have something to show
+const mockMetadataWithTags = {
+    ...mockMetadata,
+    particleProperties: {
+        ...mockMetadata.particleProperties,
+        "B+": { ...mockMetadata.particleProperties["B+"], tags: [] },
+        "K+": { ...mockMetadata.particleProperties["K+"], tags: ["kaon"] },
+        "mu+": { ...mockMetadata.particleProperties["mu+"], tags: ["muon"] },
+        "mu-": { ...mockMetadata.particleProperties["mu-"], tags: ["muon"] },
+    },
+};
+let mockMetadataValue = mockMetadataWithTags;
+vi.mock("../../providers/MetadataProvider", () => ({
+    useMetadata: () => mockMetadataValue,
+}));
+vi.mock("../../config", () => ({
+    config: {
+        disabledTupleTools: [],
+        tupleToolValidation: {},
+        particleTagGroupStyles: {
+            category: "dark",
+            charge: "primary",
+            flavour: "success",
+            spin: "danger",
+            lifetime: "secondary",
+        },
+    },
+}));
+let mockDtt = createMockDtt("MyTree");
+let mockSelectedBranch = [];
+const mockSetSelectedBranch = vi.fn();
+vi.mock("../../providers/DttProvider", () => ({
+    useDtt: () => ({
+        dtt: mockDtt,
+        selectedBranch: mockSelectedBranch,
+        setSelectedBranch: mockSetSelectedBranch,
+    }),
+}));
+describe("ParticleTagFilters", () => {
+    beforeEach(() => {
+        mockDtt = createMockDtt("MyTree");
+        mockSelectedBranch = [];
+        mockSetSelectedBranch.mockClear();
+        mockMetadataValue = mockMetadataWithTags;
+    });
+    it("renders tag badges when particles have tags (no branch selected)", () => {
+        render(_jsx(ParticleTagFilters, {}));
+        expect(screen.getByText("muon")).toBeInTheDocument();
+        expect(screen.getByText("kaon")).toBeInTheDocument();
+    });
+    it("calls setSelectedBranch with matching branches when a tag is clicked", () => {
+        render(_jsx(ParticleTagFilters, {}));
+        fireEvent.click(screen.getByText("muon"));
+        expect(mockSetSelectedBranch).toHaveBeenCalled();
+        const branches = mockSetSelectedBranch.mock.calls[0][0];
+        expect(branches).toContain("mup");
+        expect(branches).toContain("mum");
+    });
+    it("clicking kaon tag selects only kaon branches", () => {
+        render(_jsx(ParticleTagFilters, {}));
+        fireEvent.click(screen.getByText("kaon"));
+        expect(mockSetSelectedBranch).toHaveBeenCalled();
+        const branches = mockSetSelectedBranch.mock.calls[0][0];
+        expect(branches).toContain("k");
+        expect(branches).not.toContain("mup");
+    });
+    it("renders no tag badges when all particles have empty tags", () => {
+        mockMetadataValue = mockMetadata; // all particles have tags=[]
+        const { container } = render(_jsx(ParticleTagFilters, {}));
+        expect(container.querySelectorAll(".badge").length).toBe(0);
+    });
+    it("shows only tags for the selected branch when one branch is selected", () => {
+        mockSelectedBranch = ["mup"]; // mu+ only → should see muon tag
+        render(_jsx(ParticleTagFilters, {}));
+        expect(screen.getByText("muon")).toBeInTheDocument();
+    });
+    it("shows tags common to a group when multiple branches are selected", () => {
+        mockSelectedBranch = ["mup", "mum"]; // both mu particles → muon tag common
+        render(_jsx(ParticleTagFilters, {}));
+        expect(screen.getByText("muon")).toBeInTheDocument();
+    });
+});

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

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