lhcb-ntuple-wizard-test 2.1.0 → 2.2.0

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

@@ -0,0 +1,287 @@
+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 { Accordion } from "react-bootstrap";
+import { TupleToolDocsAccordion } from "../../components/TupleToolDocsAccordion";
+import { TupleToolsAccordion } from "../../components/TupleToolsAccordion";
+import { TupleToolGroupsAccordion } from "../../components/TupleToolGroupsAccordion";
+import { ParticleLatex } from "../../components/ParticleLatex";
+import { createMockDtt, mockDecay, mockMetadata } from "../testUtils";
+import { TupleTool } from "../../models/tupleTool";
+// Helper: DTT with zero global tools (branches still present)
+function createEmptyDtt() {
+    const dtt = createMockDtt("EmptyTree");
+    // Remove all 5 default tools
+    return dtt
+        .withRemovedTool(new TupleTool("TupleToolKinematic", ""))
+        .withRemovedTool(new TupleTool("TupleToolPid", ""))
+        .withRemovedTool(new TupleTool("TupleToolANNPID", ""))
+        .withRemovedTool(new TupleTool("TupleToolGeometry", ""))
+        .withRemovedTool(new TupleTool("TupleToolEventInfo", ""));
+}
+// ---------------------------------------------------------------------------
+// Shared mocks
+// ---------------------------------------------------------------------------
+let currentMockMetadata = mockMetadata;
+vi.mock("../../providers/MetadataProvider", () => ({
+    useMetadata: () => currentMockMetadata,
+}));
+vi.mock("../../components/modals/ConfigureTupleToolModal", () => ({
+    ConfigureTupleToolModal: ({ onClose }) => (_jsx("div", { "data-testid": "config-modal", children: _jsx("button", { onClick: onClose, children: "CloseConfig" }) })),
+}));
+vi.mock("../../components/AddTupleToolButton", () => ({
+    AddTupleToolButton: () => _jsx("button", { "data-testid": "add-tool-button", children: "Add tool" }),
+}));
+vi.mock("../../components/DeleteButton", () => ({
+    DeleteButton: ({ action }) => (_jsx("button", { "data-testid": "delete-tool-button", onClick: action, children: "Delete" })),
+}));
+// Mutable dtt state for DttProvider mock
+let mockDtt = createMockDtt("MyTree");
+let mockSelectedBranch = [];
+let mockHoveredBranch = [];
+const mockSetSelectedBranch = vi.fn((b) => {
+    mockSelectedBranch = b;
+});
+const mockSetHoveredBranch = vi.fn((b) => {
+    mockHoveredBranch = b;
+});
+const mockRemoveTool = vi.fn();
+vi.mock("../../providers/DttProvider", () => ({
+    useDtt: () => ({
+        dtt: mockDtt,
+        decay: mockDecay,
+        selectedBranch: mockSelectedBranch,
+        setSelectedBranch: mockSetSelectedBranch,
+        hoveredBranch: mockHoveredBranch,
+        setHoveredBranch: mockSetHoveredBranch,
+        highlightedBranch: mockSelectedBranch,
+        addTool: vi.fn(),
+        removeTool: mockRemoveTool,
+        updateToolParam: vi.fn(),
+    }),
+}));
+// ---------------------------------------------------------------------------
+// TupleToolDocsAccordion
+// ---------------------------------------------------------------------------
+describe("TupleToolDocsAccordion", () => {
+    it("renders Documentation header for the given tool class", () => {
+        render(_jsx(TupleToolDocsAccordion, { toolClass: "TupleToolKinematic" }));
+        expect(screen.getByText(/documentation for tupleToolKinematic/i)).toBeInTheDocument();
+    });
+    it("renders 'No documentation available' when documentation is empty", () => {
+        render(_jsx(TupleToolDocsAccordion, { toolClass: "TupleToolKinematic" }));
+        // TupleToolKinematic has no documentation in mockMetadata
+        expect(screen.getByText("No documentation available.")).toBeInTheDocument();
+    });
+    it("renders documentation HTML when the tool has documentation", () => {
+        const metaWithDocs = {
+            ...mockMetadata,
+            tupleTools: {
+                ...mockMetadata.tupleTools,
+                tupleTools: {
+                    ...mockMetadata.tupleTools.tupleTools,
+                    TupleToolKinematic: {
+                        ...mockMetadata.tupleTools.tupleTools.TupleToolKinematic,
+                        documentation: "<p>Detailed kinematic documentation</p>",
+                    },
+                },
+            },
+        };
+        currentMockMetadata = metaWithDocs;
+        render(_jsx(TupleToolDocsAccordion, { toolClass: "TupleToolKinematic" }));
+        expect(screen.getByText("Detailed kinematic documentation")).toBeInTheDocument();
+        currentMockMetadata = mockMetadata;
+    });
+});
+// ---------------------------------------------------------------------------
+// ParticleLatex
+// ---------------------------------------------------------------------------
+describe("ParticleLatex", () => {
+    beforeEach(() => {
+        mockDtt = createMockDtt("MyTree");
+    });
+    it("renders an InlineMath element", () => {
+        render(_jsx(ParticleLatex, { particleId: "head" }));
+        expect(screen.getByTestId("inline-math")).toBeInTheDocument();
+    });
+    it("renders the particle latex when highlighted=true", () => {
+        render(_jsx(ParticleLatex, { particleId: "head", highlighted: true }));
+        expect(screen.getByTestId("inline-math")).toBeInTheDocument();
+    });
+});
+// ---------------------------------------------------------------------------
+// TupleToolsAccordion
+// ---------------------------------------------------------------------------
+describe("TupleToolsAccordion — no tools", () => {
+    beforeEach(() => {
+        mockDtt = createEmptyDtt();
+        mockSelectedBranch = [];
+        mockHoveredBranch = [];
+    });
+    it("renders the accordion header containing tool count", () => {
+        const { container } = render(_jsx("div", { children: _jsx(TupleToolsAccordion, {}) }));
+        const btn = container.querySelector("button.accordion-button");
+        expect(btn?.textContent).toMatch(/0 TupleTools/);
+    });
+    it("renders 'No TupleTools have been added' message", () => {
+        render(_jsx("div", { children: _jsx(TupleToolsAccordion, {}) }));
+        expect(screen.getByText(/no tupletools have been added/i)).toBeInTheDocument();
+    });
+    it("renders the Add tool button", () => {
+        render(_jsx("div", { children: _jsx(TupleToolsAccordion, {}) }));
+        expect(screen.getByTestId("add-tool-button")).toBeInTheDocument();
+    });
+});
+describe("TupleToolsAccordion — with selected group branch", () => {
+    beforeEach(() => {
+        mockDtt = createMockDtt("MyTree");
+        mockSelectedBranch = ["head", "k"];
+        mockHoveredBranch = [];
+    });
+    it("shows '(group)' in the header when multiple branches are selected", () => {
+        const { container } = render(_jsx("div", { children: _jsx(TupleToolsAccordion, {}) }));
+        const btn = container.querySelector("button.accordion-button");
+        expect(btn?.textContent).toMatch(/\(group\)/);
+    });
+});
+describe("TupleToolsAccordion — with tools", () => {
+    beforeEach(() => {
+        mockDtt = createMockDtt("MyTree").withAddedTool(new TupleTool("TupleToolKinematic", ""));
+        mockSelectedBranch = [];
+        mockHoveredBranch = [];
+    });
+    it("renders the tool name", () => {
+        render(_jsx("div", { children: _jsx(TupleToolsAccordion, {}) }));
+        expect(screen.getByText("TupleToolKinematic")).toBeInTheDocument();
+    });
+    it("shows configure modal when configure button is clicked", () => {
+        const { container } = render(_jsx("div", { children: _jsx(TupleToolsAccordion, {}) }));
+        // Find the outline-secondary button (configure), not the delete button
+        const configBtn = container.querySelector(".btn-outline-secondary");
+        if (configBtn)
+            fireEvent.click(configBtn);
+        expect(screen.queryByTestId("config-modal")).toBeInTheDocument();
+    });
+    it("calls removeTool when delete button is clicked", () => {
+        render(_jsx("div", { children: _jsx(TupleToolsAccordion, {}) }));
+        fireEvent.click(screen.getAllByTestId("delete-tool-button")[0]);
+        expect(mockRemoveTool).toHaveBeenCalled();
+    });
+    it("shows configure modal when configure button is clicked (Accordion open)", () => {
+        const { container } = render(_jsx(Accordion, { defaultActiveKey: "0", children: _jsx(TupleToolsAccordion, {}) }));
+        const configBtn = container.querySelector(".btn-outline-secondary");
+        expect(configBtn).not.toBeNull();
+        fireEvent.click(configBtn);
+        expect(screen.getByTestId("config-modal")).toBeInTheDocument();
+        // Also test that onClose hides the modal
+        fireEvent.click(screen.getByText("CloseConfig"));
+        expect(screen.queryByTestId("config-modal")).not.toBeInTheDocument();
+    });
+});
+// ---------------------------------------------------------------------------
+// TupleToolGroupsAccordion
+// ---------------------------------------------------------------------------
+describe("TupleToolGroupsAccordion — no groups", () => {
+    beforeEach(() => {
+        mockDtt = createEmptyDtt();
+        mockSelectedBranch = [];
+        mockHoveredBranch = [];
+    });
+    it("renders header containing group count", () => {
+        const { container } = render(_jsx("div", { children: _jsx(TupleToolGroupsAccordion, { setActiveKey: vi.fn() }) }));
+        const btn = container.querySelector("button.accordion-button");
+        expect(btn?.textContent).toMatch(/0 groups/);
+    });
+    it("shows message when no groups exist and no branch is selected", () => {
+        render(_jsx("div", { children: _jsx(TupleToolGroupsAccordion, { setActiveKey: vi.fn() }) }));
+        expect(screen.getByText(/no groups have been created yet/i)).toBeInTheDocument();
+    });
+    it("shows 'Select multiple particles' when exactly 1 branch is selected", () => {
+        mockSelectedBranch = ["head"];
+        render(_jsx("div", { children: _jsx(TupleToolGroupsAccordion, { setActiveKey: vi.fn() }) }));
+        expect(screen.getByText(/select multiple particles/i)).toBeInTheDocument();
+    });
+    it("shows AddTupleToolButton when multiple branches are selected but no group exists", () => {
+        mockSelectedBranch = ["head", "k"];
+        render(_jsx("div", { children: _jsx(TupleToolGroupsAccordion, { setActiveKey: vi.fn() }) }));
+        expect(screen.getByTestId("add-tool-button")).toBeInTheDocument();
+    });
+});
+describe("TupleToolGroupsAccordion — with groups", () => {
+    beforeEach(() => {
+        // Create a DTT with a group by adding a tool to a multi-branch selection
+        mockDtt = createEmptyDtt().withAddedTool(new TupleTool("TupleToolKinematic", ""), ["head", "k"]);
+        mockSelectedBranch = [];
+        mockHoveredBranch = [];
+    });
+    it("renders '1 group' in the header", () => {
+        const { container } = render(_jsx("div", { children: _jsx(TupleToolGroupsAccordion, { setActiveKey: vi.fn() }) }));
+        const btn = container.querySelector("button.accordion-button");
+        expect(btn?.textContent).toMatch(/1 group/);
+    });
+    it("renders the group entry in the list", () => {
+        render(_jsx("div", { children: _jsx(TupleToolGroupsAccordion, { setActiveKey: vi.fn() }) }));
+        // The group list item should be present (rendered by ParticleLatex → InlineMath)
+        expect(screen.getAllByTestId("inline-math").length).toBeGreaterThan(0);
+    });
+    it("calls setActiveKey and setSelectedBranch when a group is clicked", () => {
+        const mockSetActiveKey = vi.fn();
+        const { container } = render(_jsx("div", { children: _jsx(TupleToolGroupsAccordion, { setActiveKey: mockSetActiveKey }) }));
+        // Click the list item
+        const listItem = container.querySelector(".list-group-item");
+        if (listItem)
+            fireEvent.click(listItem);
+        expect(mockSetActiveKey).toHaveBeenCalledWith("0");
+        expect(mockSetSelectedBranch).toHaveBeenCalled();
+    });
+    it("applies hover background color when hoveredBranch matches the group", () => {
+        mockHoveredBranch = ["head", "k"];
+        const { container } = render(_jsx("div", { children: _jsx(TupleToolGroupsAccordion, { setActiveKey: vi.fn() }) }));
+        const listItem = container.querySelector(".list-group-item");
+        expect(listItem?.style.backgroundColor).toBe("var(--bs-gray-100)");
+    });
+    it("calls setHoveredBranch when mouseEnter on group item", () => {
+        const { container } = render(_jsx("div", { children: _jsx(TupleToolGroupsAccordion, { setActiveKey: vi.fn() }) }));
+        const listItem = container.querySelector(".list-group-item");
+        if (listItem)
+            fireEvent.mouseEnter(listItem);
+        expect(mockSetHoveredBranch).toHaveBeenCalled();
+    });
+    it("calls setHoveredBranch([]) when mouseLeave on group item", () => {
+        const { container } = render(_jsx("div", { children: _jsx(TupleToolGroupsAccordion, { setActiveKey: vi.fn() }) }));
+        const listItem = container.querySelector(".list-group-item");
+        if (listItem)
+            fireEvent.mouseLeave(listItem);
+        expect(mockSetHoveredBranch).toHaveBeenCalledWith([]);
+    });
+});
+describe("TupleToolGroupsAccordion — new group selection (lines 76-104)", () => {
+    beforeEach(() => {
+        // DTT with a group at "head,k", but selectedBranch is a different pair "mup,mum"
+        mockDtt = createEmptyDtt().withAddedTool(new TupleTool("TupleToolKinematic", ""), ["head", "k"]);
+        mockSelectedBranch = ["mup", "mum"];
+        mockHoveredBranch = [];
+    });
+    it("shows a new group item when selectedBranch is a multi-selection not yet a group", () => {
+        const { container } = render(_jsx("div", { children: _jsx(TupleToolGroupsAccordion, { setActiveKey: vi.fn() }) }));
+        // Should have 2 list items: the existing group + the new selection
+        const listItems = container.querySelectorAll(".list-group-item");
+        expect(listItems.length).toBe(2);
+    });
+    it("the new group item shows a PlusLg (success) button", () => {
+        const { container } = render(_jsx("div", { children: _jsx(TupleToolGroupsAccordion, { setActiveKey: vi.fn() }) }));
+        // The success button is the 'create group' button on the new selection item
+        const successBtn = container.querySelector(".btn-success");
+        expect(successBtn).toBeInTheDocument();
+    });
+    it("clicking the new group item calls setActiveKey and setSelectedBranch", () => {
+        const mockSetActiveKey = vi.fn();
+        const { container } = render(_jsx("div", { children: _jsx(TupleToolGroupsAccordion, { setActiveKey: mockSetActiveKey }) }));
+        const listItems = container.querySelectorAll(".list-group-item");
+        // The second list item is the new selection
+        if (listItems[1])
+            fireEvent.click(listItems[1]);
+        expect(mockSetActiveKey).toHaveBeenCalledWith("0");
+        expect(mockSetSelectedBranch).toHaveBeenCalled();
+    });
+});

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

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

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

@@ -0,0 +1,96 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, expect, it, vi } from "vitest";
+import { fireEvent, render, screen } from "@testing-library/react";
+import { ProductionNameInput } from "../../components/ProductionNameInput";
+import { RequestEmailInput } from "../../components/RequestEmailInput";
+// ---------------------------------------------------------------------------
+// Shared mock state for RequestProvider
+// ---------------------------------------------------------------------------
+const mockSetProductionName = vi.fn();
+const mockSetContactEmails = vi.fn();
+let mockProductionName = "";
+let mockContactEmails = [];
+let mockShowErrors = false;
+let mockIsEmailValid = true;
+vi.mock("../../providers/RequestProvider", () => ({
+    useRequest: () => ({
+        productionName: mockProductionName,
+        setProductionName: mockSetProductionName,
+        contactEmails: mockContactEmails,
+        setContactEmails: mockSetContactEmails,
+        showErrors: mockShowErrors,
+        validation: { isEmailValid: mockIsEmailValid },
+    }),
+}));
+// ---------------------------------------------------------------------------
+// ProductionNameInput
+// ---------------------------------------------------------------------------
+describe("ProductionNameInput", () => {
+    it("renders an input with the current production name", () => {
+        mockProductionName = "MyAnalysis";
+        render(_jsx(ProductionNameInput, {}));
+        expect(screen.getByDisplayValue("MyAnalysis")).toBeInTheDocument();
+    });
+    it("renders placeholder when production name is empty", () => {
+        mockProductionName = "";
+        render(_jsx(ProductionNameInput, {}));
+        expect(screen.getByPlaceholderText("MyAnalysis")).toBeInTheDocument();
+    });
+    it("calls setProductionName when the user types (sanitizing special chars)", () => {
+        mockProductionName = "";
+        render(_jsx(ProductionNameInput, {}));
+        fireEvent.change(screen.getByRole("textbox"), { target: { value: "My Analysis!" } });
+        // Non-word characters are stripped by the onChange handler
+        expect(mockSetProductionName).toHaveBeenCalledWith("MyAnalysis");
+    });
+    it("shows validation error when showErrors is true and name is empty", () => {
+        mockProductionName = "";
+        mockShowErrors = true;
+        render(_jsx(ProductionNameInput, {}));
+        expect(screen.getByText(/please enter a production name/i)).toBeInTheDocument();
+        mockShowErrors = false;
+    });
+    it("does not mark input as invalid when showErrors is false", () => {
+        mockProductionName = "";
+        mockShowErrors = false;
+        render(_jsx(ProductionNameInput, {}));
+        expect(screen.getByRole("textbox")).not.toHaveClass("is-invalid");
+    });
+});
+// ---------------------------------------------------------------------------
+// RequestEmailInput
+// ---------------------------------------------------------------------------
+describe("RequestEmailInput", () => {
+    it("renders the current emails joined by ', '", () => {
+        mockContactEmails = ["a@b.com", "c@d.com"];
+        render(_jsx(RequestEmailInput, {}));
+        expect(screen.getByDisplayValue("a@b.com, c@d.com")).toBeInTheDocument();
+    });
+    it("renders placeholder when no emails", () => {
+        mockContactEmails = [];
+        render(_jsx(RequestEmailInput, {}));
+        expect(screen.getByPlaceholderText("name@example.com")).toBeInTheDocument();
+    });
+    it("calls setContactEmails with split values on change", () => {
+        mockContactEmails = [];
+        render(_jsx(RequestEmailInput, {}));
+        fireEvent.change(screen.getByRole("textbox"), { target: { value: "a@b.com, c@d.com" } });
+        expect(mockSetContactEmails).toHaveBeenCalledWith(["a@b.com", "c@d.com"]);
+    });
+    it("shows validation error when showErrors=true and email is invalid", () => {
+        mockContactEmails = ["notvalid"];
+        mockShowErrors = true;
+        mockIsEmailValid = false;
+        render(_jsx(RequestEmailInput, {}));
+        expect(screen.getByText(/please enter valid email addresses/i)).toBeInTheDocument();
+        mockShowErrors = false;
+        mockIsEmailValid = true;
+    });
+    it("does not mark input as invalid when email is valid", () => {
+        mockContactEmails = ["a@b.com"];
+        mockShowErrors = false;
+        mockIsEmailValid = true;
+        render(_jsx(RequestEmailInput, {}));
+        expect(screen.getByRole("textbox")).not.toHaveClass("is-invalid");
+    });
+});

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

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

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

@@ -0,0 +1,137 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, expect, it, vi } from "vitest";
+import { render, screen } from "@testing-library/react";
+import { TupleToolLabel } from "../../components/TupleToolLabel";
+import { DecayTagBadge } from "../../components/DecayTagBadge";
+import { ParticleTagBadge } from "../../components/ParticleTagBadge";
+import { StrippingLineVersionBadge } from "../../components/StrippingLineVersionBadge";
+import { StrippingLineInfo } from "../../components/StrippingLineInfo";
+import { StrippingLineInfoButton } from "../../components/StrippingLineInfoButton";
+import { mockStrippingLine, mockStrippingLinePrescaled } from "../testUtils";
+import { TupleTool } from "../../models/tupleTool";
+// ---------------------------------------------------------------------------
+// TupleToolLabel
+// ---------------------------------------------------------------------------
+describe("TupleToolLabel", () => {
+    it("renders the tool class name", () => {
+        render(_jsx(TupleToolLabel, { tool: new TupleTool("TupleToolKinematic", "") }));
+        expect(screen.getByText("TupleToolKinematic")).toBeInTheDocument();
+    });
+    it("renders the tool instance name when set", () => {
+        render(_jsx(TupleToolLabel, { tool: new TupleTool("TupleToolKinematic", "myKin") }));
+        expect(screen.getByText("myKin")).toBeInTheDocument();
+    });
+    it("renders an empty name slot when name is not set", () => {
+        const { container } = render(_jsx(TupleToolLabel, { tool: new TupleTool("TupleToolKinematic", "") }));
+        const nameParagraph = container.querySelector("p.text-muted");
+        expect(nameParagraph?.textContent).toBe("");
+    });
+});
+// ---------------------------------------------------------------------------
+// DecayTagBadge
+// ---------------------------------------------------------------------------
+describe("DecayTagBadge", () => {
+    it("renders the tag label text", () => {
+        render(_jsx(DecayTagBadge, { tag: "B2OC" }));
+        expect(screen.getByText("B2OC")).toBeInTheDocument();
+    });
+    it("uses warning background for non-warn tags", () => {
+        render(_jsx(DecayTagBadge, { tag: "B2OC" }));
+        // B2OC has warn: false → bg-warning
+        expect(screen.getByText("B2OC")).toHaveClass("bg-warning");
+    });
+    it("uses danger background for warn tags", () => {
+        render(_jsx(DecayTagBadge, { tag: "SLOW" }));
+        // SLOW has warn: true → bg-danger
+        expect(screen.getByText("SLOW")).toHaveClass("bg-danger");
+    });
+});
+// ---------------------------------------------------------------------------
+// ParticleTagBadge
+// ---------------------------------------------------------------------------
+describe("ParticleTagBadge", () => {
+    it("renders the tag label", () => {
+        render(_jsx(ParticleTagBadge, { tag: { label: "muon", group: "category" } }));
+        expect(screen.getByText("muon")).toBeInTheDocument();
+    });
+    it("is fully opaque when enabled", () => {
+        const { container } = render(_jsx(ParticleTagBadge, { tag: { label: "muon", group: "category" }, enabled: true }));
+        const badge = container.querySelector(".badge");
+        expect(badge.style.opacity).toBe("1");
+    });
+    it("is dimmed when disabled", () => {
+        const { container } = render(_jsx(ParticleTagBadge, { tag: { label: "muon", group: "category" }, enabled: false }));
+        const badge = container.querySelector(".badge");
+        expect(badge.style.opacity).toBe("0.15");
+    });
+    it("calls onClick when clicked", () => {
+        const onClick = vi.fn();
+        render(_jsx(ParticleTagBadge, { tag: { label: "kaon", group: "flavour" }, onClick: onClick }));
+        screen.getByText("kaon").click();
+        expect(onClick).toHaveBeenCalledOnce();
+    });
+});
+// ---------------------------------------------------------------------------
+// StrippingLineVersionBadge
+// ---------------------------------------------------------------------------
+describe("StrippingLineVersionBadge", () => {
+    it("renders the version number prefixed with S", () => {
+        render(_jsx(StrippingLineVersionBadge, { version: "28r2" }));
+        expect(screen.getByText("S28r2")).toBeInTheDocument();
+    });
+    it("renders without a link when showLink is false", () => {
+        const { container } = render(_jsx(StrippingLineVersionBadge, { version: "28r2", showLink: false }));
+        expect(container.querySelector("a")).toBeNull();
+    });
+    it("renders a link when showLink is true and line is provided", () => {
+        const { container } = render(_jsx(StrippingLineVersionBadge, { version: "28r2", line: mockStrippingLine, showLink: true }));
+        expect(container.querySelector("a")).not.toBeNull();
+    });
+});
+// ---------------------------------------------------------------------------
+// StrippingLineInfo
+// ---------------------------------------------------------------------------
+describe("StrippingLineInfo", () => {
+    it("renders the line name in compact mode", () => {
+        render(_jsx(StrippingLineInfo, { line: mockStrippingLine }));
+        expect(screen.getByText(mockStrippingLine.line)).toBeInTheDocument();
+    });
+    it("renders version badges in compact mode", () => {
+        render(_jsx(StrippingLineInfo, { line: mockStrippingLine }));
+        expect(screen.getByText("S28r2")).toBeInTheDocument();
+    });
+    it("renders verbose information when verbose=true", () => {
+        render(_jsx(StrippingLineInfo, { line: mockStrippingLine, verbose: true }));
+        expect(screen.getByText(/stream/i, { exact: false })).toBeInTheDocument();
+        expect(screen.getByText("Leptonic")).toBeInTheDocument();
+    });
+    it("shows DaVinci version hint in verbose mode", () => {
+        render(_jsx(StrippingLineInfo, { line: mockStrippingLine, verbose: true }));
+        expect(screen.getByText(/DaVinci version/i, { exact: false })).toBeInTheDocument();
+    });
+    it("shows stripping description in verbose mode", () => {
+        render(_jsx(StrippingLineInfo, { line: mockStrippingLine, verbose: true }));
+        expect(screen.getByText(/Stripping 28r2/i, { exact: false })).toBeInTheDocument();
+    });
+    it("shows a prescale warning when prescale is not 1", () => {
+        render(_jsx(StrippingLineInfo, { line: mockStrippingLinePrescaled, verbose: true }));
+        expect(screen.getByText(/Prescale: 0\.5/)).toBeInTheDocument();
+    });
+});
+// ---------------------------------------------------------------------------
+// StrippingLineInfoButton
+// ---------------------------------------------------------------------------
+describe("StrippingLineInfoButton", () => {
+    it("renders a button", () => {
+        render(_jsx(StrippingLineInfoButton, { line: null }));
+        expect(screen.getByRole("button")).toBeInTheDocument();
+    });
+    it("is disabled when line is null", () => {
+        render(_jsx(StrippingLineInfoButton, { line: null }));
+        expect(screen.getByRole("button")).toBeDisabled();
+    });
+    it("is enabled when a line is provided", () => {
+        render(_jsx(StrippingLineInfoButton, { line: mockStrippingLine }));
+        expect(screen.getByRole("button")).not.toBeDisabled();
+    });
+});

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

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