lhcb-ntuple-wizard-test 2.1.0 → 2.2.0

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

@@ -0,0 +1,129 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, expect, it, vi, afterEach } from "vitest";
+import { render, screen, waitFor } from "@testing-library/react";
+import { renderHook } from "@testing-library/react";
+import { MetadataProvider, useMetadata } from "../../providers/MetadataProvider";
+// ---------------------------------------------------------------------------
+// Mock pako — inflate returns raw bytes of an empty JSON object so the
+// provider can call JSON.parse without real gzip decompression.
+// ---------------------------------------------------------------------------
+const mockInflatedBytes = new TextEncoder().encode(JSON.stringify({}));
+// Restore the real module — the global mock in mockSetup.tsx is overridden here
+vi.mock("../../providers/MetadataProvider", async (importOriginal) => await importOriginal());
+vi.mock("pako", () => ({
+    default: { inflate: vi.fn(() => mockInflatedBytes) },
+}));
+// Stub config so the provider only fetches one file — keeps tests fast.
+vi.mock("../../config", () => ({
+    config: {
+        metadata_baseurl: "https://example.com/",
+        metadata_files: { particleProperties: "particles" },
+        batch_size: 10,
+        particleTagGroupStyles: {},
+        dttGraphOptions: {},
+        disabledTupleTools: [],
+        tupleToolValidation: {},
+    },
+}));
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const successResponse = {
+    ok: true,
+    arrayBuffer: () => Promise.resolve(new ArrayBuffer(0)),
+};
+function wrapper({ children }) {
+    return _jsx(MetadataProvider, { children: children });
+}
+// ---------------------------------------------------------------------------
+// Tests — loading state
+// ---------------------------------------------------------------------------
+describe("MetadataProvider — loading state", () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it("shows a loading indicator while the fetch is pending", () => {
+        // fetch never resolves — component stays in loading state
+        vi.stubGlobal("fetch", vi.fn(() => new Promise(() => { })));
+        render(_jsx(MetadataProvider, { children: _jsx("div", { "data-testid": "children" }) }));
+        expect(screen.getByTestId("loading-indicator")).toBeInTheDocument();
+        expect(screen.queryByTestId("children")).not.toBeInTheDocument();
+    });
+});
+// ---------------------------------------------------------------------------
+// Tests — success state
+// ---------------------------------------------------------------------------
+describe("MetadataProvider — success state", () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it("renders children once metadata has loaded", async () => {
+        vi.stubGlobal("fetch", vi.fn().mockResolvedValue(successResponse));
+        render(_jsx(MetadataProvider, { children: _jsx("div", { "data-testid": "children" }) }));
+        await waitFor(() => expect(screen.getByTestId("children")).toBeInTheDocument());
+        expect(screen.queryByTestId("loading-indicator")).not.toBeInTheDocument();
+    });
+    it("hides the loading indicator after metadata loads", async () => {
+        vi.stubGlobal("fetch", vi.fn().mockResolvedValue(successResponse));
+        render(_jsx(MetadataProvider, { children: _jsx("div", { "data-testid": "children" }) }));
+        await waitFor(() => screen.getByTestId("children"));
+        expect(screen.queryByTestId("loading-indicator")).not.toBeInTheDocument();
+    });
+    it("provides metadata context to children via useMetadata()", async () => {
+        vi.stubGlobal("fetch", vi.fn().mockResolvedValue(successResponse));
+        const { result } = renderHook(() => useMetadata(), { wrapper });
+        // Wait for metadata to load (hook result changes from throwing to returning)
+        await waitFor(() => expect(result.current).toBeTruthy());
+    });
+});
+// ---------------------------------------------------------------------------
+// Tests — error state
+// ---------------------------------------------------------------------------
+describe("MetadataProvider — error state", () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it("shows an error message when the fetch rejects", async () => {
+        vi.stubGlobal("fetch", vi.fn().mockRejectedValue(new Error("Network error")));
+        render(_jsx(MetadataProvider, { children: _jsx("div", { "data-testid": "children" }) }));
+        await waitFor(() => expect(screen.getByText(/error/i)).toBeInTheDocument());
+        expect(screen.queryByTestId("children")).not.toBeInTheDocument();
+        expect(screen.queryByTestId("loading-indicator")).not.toBeInTheDocument();
+    });
+    it("does not render children when an error occurs", async () => {
+        vi.stubGlobal("fetch", vi.fn().mockRejectedValue(new Error("Network error")));
+        render(_jsx(MetadataProvider, { children: _jsx("div", { "data-testid": "children" }) }));
+        await waitFor(() => screen.getByText(/error/i));
+        expect(screen.queryByTestId("children")).not.toBeInTheDocument();
+    });
+});
+// ---------------------------------------------------------------------------
+// Tests — useMetadata hook
+// ---------------------------------------------------------------------------
+describe("useMetadata()", () => {
+    it("throws when used outside a MetadataProvider", () => {
+        expect(() => renderHook(() => useMetadata())).toThrow("useMetadata must be used inside MetadataProvider");
+    });
+});
+// ---------------------------------------------------------------------------
+// Tests — non-OK response (lines 73-75)
+// ---------------------------------------------------------------------------
+describe("MetadataProvider — non-OK fetch response", () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it("handles a non-OK response (e.g. 404) gracefully", async () => {
+        const notFoundResponse = {
+            ok: false,
+            status: 404,
+            arrayBuffer: () => Promise.resolve(new ArrayBuffer(0)),
+        };
+        vi.stubGlobal("fetch", vi.fn().mockResolvedValue(notFoundResponse));
+        const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
+        render(_jsx(MetadataProvider, { children: _jsx("div", { "data-testid": "children" }) }));
+        // The provider should eventually show an error (loadDict returns null, setMetadata never fires)
+        // or the error boundary triggers; just verify the component doesn't throw
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        consoleSpy.mockRestore();
+    });
+});

package/dist/tests/providers/RequestProvider.test.d.ts

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

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

@@ -0,0 +1,306 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, expect, it, vi } from "vitest";
+import { act, renderHook } from "@testing-library/react";
+import { RequestProvider, useRequest } from "../../providers/RequestProvider";
+import { createMockDtt, createMockRow, mockStrippingLine } from "../testUtils";
+// ---------------------------------------------------------------------------
+// Mock RowsProvider — each test mutates these to set up scenarios
+// ---------------------------------------------------------------------------
+let mockRows = [createMockRow()];
+let mockConfiguredRows = mockRows.filter((r) => r.dtt);
+const mockSetRows = vi.fn();
+vi.mock("../../providers/RowsProvider", () => ({
+    useRows: () => ({
+        rows: mockRows,
+        configuredRows: mockConfiguredRows,
+        setRows: mockSetRows,
+        updateRow: vi.fn(),
+        removeRow: vi.fn(),
+        generateAllFiles: vi.fn(),
+    }),
+}));
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeWrapper(emailIsKnown = false) {
+    return function Wrapper({ children }) {
+        return _jsx(RequestProvider, { emailIsKnown: emailIsKnown, children: children });
+    };
+}
+function renderProvider(emailIsKnown = false) {
+    return renderHook(() => useRequest(), { wrapper: makeWrapper(emailIsKnown) });
+}
+// ---------------------------------------------------------------------------
+// Validation: isEmptySession
+// ---------------------------------------------------------------------------
+describe("RequestProvider — isEmptySession", () => {
+    it("is true when no name, no emails and no rows", () => {
+        mockRows = [];
+        mockConfiguredRows = [];
+        const { result } = renderProvider();
+        expect(result.current.validation.isEmptySession).toBe(true);
+    });
+    it("is false when there is at least one row", () => {
+        mockRows = [createMockRow()];
+        mockConfiguredRows = [];
+        const { result } = renderProvider();
+        expect(result.current.validation.isEmptySession).toBe(false);
+    });
+    it("is false after a production name is entered", () => {
+        mockRows = [];
+        mockConfiguredRows = [];
+        const { result } = renderProvider();
+        act(() => result.current.setProductionName("TestProd"));
+        expect(result.current.validation.isEmptySession).toBe(false);
+    });
+});
+// ---------------------------------------------------------------------------
+// Validation: isEmailValid
+// ---------------------------------------------------------------------------
+describe("RequestProvider — isEmailValid", () => {
+    it("is false when contact emails list is empty", () => {
+        mockRows = [];
+        mockConfiguredRows = [];
+        const { result } = renderProvider();
+        expect(result.current.validation.isEmailValid).toBe(false);
+    });
+    it("is true for a valid email address", () => {
+        mockRows = [];
+        mockConfiguredRows = [];
+        const { result } = renderProvider();
+        act(() => result.current.setContactEmails(["user@cern.ch"]));
+        expect(result.current.validation.isEmailValid).toBe(true);
+    });
+    it("is false when any email is invalid", () => {
+        mockRows = [];
+        mockConfiguredRows = [];
+        const { result } = renderProvider();
+        act(() => result.current.setContactEmails(["user@cern.ch", "notvalid"]));
+        expect(result.current.validation.isEmailValid).toBe(false);
+    });
+});
+// ---------------------------------------------------------------------------
+// Validation: allRowsHaveDtt
+// ---------------------------------------------------------------------------
+describe("RequestProvider — allRowsHaveDtt", () => {
+    it("is false when no rows have a DTT", () => {
+        mockRows = [createMockRow({ dtt: null })];
+        mockConfiguredRows = [];
+        const { result } = renderProvider();
+        expect(result.current.validation.allRowsHaveDtt).toBe(false);
+    });
+    it("is true when all rows have a DTT", () => {
+        const row = createMockRow({ dtt: createMockDtt() });
+        mockRows = [row];
+        mockConfiguredRows = [row];
+        const { result } = renderProvider();
+        expect(result.current.validation.allRowsHaveDtt).toBe(true);
+    });
+});
+// ---------------------------------------------------------------------------
+// Validation: allRowsHaveStrippingLine
+// ---------------------------------------------------------------------------
+describe("RequestProvider — allRowsHaveStrippingLine", () => {
+    it("is false when a row has no stripping line", () => {
+        mockRows = [createMockRow({ line: null })];
+        mockConfiguredRows = [];
+        const { result } = renderProvider();
+        expect(result.current.validation.allRowsHaveStrippingLine).toBe(false);
+    });
+    it("is true when all rows have a stripping line", () => {
+        mockRows = [createMockRow({ line: mockStrippingLine })];
+        mockConfiguredRows = [];
+        const { result } = renderProvider();
+        expect(result.current.validation.allRowsHaveStrippingLine).toBe(true);
+    });
+});
+// ---------------------------------------------------------------------------
+// Validation: allRowsHavePaths
+// ---------------------------------------------------------------------------
+describe("RequestProvider — allRowsHavePaths", () => {
+    it("is false when a row has no paths", () => {
+        mockRows = [createMockRow({ paths: [] })];
+        mockConfiguredRows = [];
+        const { result } = renderProvider();
+        expect(result.current.validation.allRowsHavePaths).toBe(false);
+    });
+    it("is true when all rows have at least one path", () => {
+        mockRows = [createMockRow({ paths: ["/some/path/DIMUON.DST"] })];
+        mockConfiguredRows = [];
+        const { result } = renderProvider();
+        expect(result.current.validation.allRowsHavePaths).toBe(true);
+    });
+});
+// ---------------------------------------------------------------------------
+// Validation: validDttNames
+// ---------------------------------------------------------------------------
+describe("RequestProvider — validDttNames", () => {
+    it("is true when there are no configured rows (vacuous truth)", () => {
+        mockRows = [];
+        mockConfiguredRows = [];
+        const { result } = renderProvider();
+        expect(result.current.validation.validDttNames).toBe(true);
+    });
+    it("is true when all DTT names are unique and non-empty", () => {
+        const row1 = createMockRow({ id: 0, dtt: createMockDtt("TreeA") });
+        const row2 = createMockRow({ id: 1, dtt: createMockDtt("TreeB") });
+        mockRows = [row1, row2];
+        mockConfiguredRows = [
+            row1,
+            row2,
+        ];
+        const { result } = renderProvider();
+        expect(result.current.validation.validDttNames).toBe(true);
+    });
+    it("is false when two rows have the same DTT name", () => {
+        const row1 = createMockRow({ id: 0, dtt: createMockDtt("SameName") });
+        const row2 = createMockRow({ id: 1, dtt: createMockDtt("SameName") });
+        mockRows = [row1, row2];
+        mockConfiguredRows = [
+            row1,
+            row2,
+        ];
+        const { result } = renderProvider();
+        expect(result.current.validation.validDttNames).toBe(false);
+    });
+});
+// ---------------------------------------------------------------------------
+// trySubmit / showErrors
+// ---------------------------------------------------------------------------
+describe("RequestProvider — trySubmit / showErrors", () => {
+    it("showErrors is false before trySubmit is called", () => {
+        mockRows = [];
+        mockConfiguredRows = [];
+        const { result } = renderProvider();
+        expect(result.current.showErrors).toBe(false);
+    });
+    it("showErrors becomes true after trySubmit when form is incomplete", () => {
+        mockRows = [];
+        mockConfiguredRows = [];
+        const { result } = renderProvider();
+        act(() => void result.current.trySubmit());
+        expect(result.current.showErrors).toBe(true);
+    });
+    it("trySubmit returns false when form is not ready to submit", () => {
+        mockRows = [];
+        mockConfiguredRows = [];
+        const { result } = renderProvider();
+        let canSubmit = true;
+        act(() => {
+            canSubmit = result.current.trySubmit();
+        });
+        expect(canSubmit).toBe(false);
+    });
+    it("trySubmit returns true when emailIsKnown=true and form is otherwise complete", () => {
+        const row = createMockRow({
+            dtt: createMockDtt("MyTree"),
+            line: mockStrippingLine,
+            paths: ["/some/path/DIMUON.DST"],
+        });
+        mockRows = [row];
+        mockConfiguredRows = [row];
+        const { result } = renderProvider(true /* emailIsKnown */);
+        act(() => result.current.setProductionName("MyProd"));
+        let canSubmit = false;
+        act(() => {
+            canSubmit = result.current.trySubmit();
+        });
+        expect(canSubmit).toBe(true);
+    });
+});
+// ---------------------------------------------------------------------------
+// clearAll
+// ---------------------------------------------------------------------------
+describe("RequestProvider — clearAll", () => {
+    it("resets productionName to empty string", () => {
+        mockRows = [];
+        mockConfiguredRows = [];
+        const { result } = renderProvider();
+        act(() => result.current.setProductionName("TestProd"));
+        act(() => result.current.clearAll());
+        expect(result.current.productionName).toBe("");
+    });
+    it("resets contactEmails to empty array", () => {
+        mockRows = [];
+        mockConfiguredRows = [];
+        const { result } = renderProvider();
+        act(() => result.current.setContactEmails(["a@b.com"]));
+        act(() => result.current.clearAll());
+        expect(result.current.contactEmails).toEqual([]);
+    });
+    it("resets showErrors to false", () => {
+        mockRows = [];
+        mockConfiguredRows = [];
+        const { result } = renderProvider();
+        act(() => void result.current.trySubmit());
+        act(() => result.current.clearAll());
+        expect(result.current.showErrors).toBe(false);
+    });
+});
+// ---------------------------------------------------------------------------
+// localStorage persistence
+// ---------------------------------------------------------------------------
+describe("RequestProvider — localStorage", () => {
+    it("persists productionName to localStorage on update", () => {
+        mockRows = [];
+        mockConfiguredRows = [];
+        const { result } = renderProvider();
+        act(() => result.current.setProductionName("Persisted"));
+        expect(localStorage.getItem("name")).toBe("Persisted");
+    });
+    it("persists contactEmails to localStorage on update", () => {
+        mockRows = [];
+        mockConfiguredRows = [];
+        const { result } = renderProvider();
+        act(() => result.current.setContactEmails(["x@y.com"]));
+        expect(localStorage.getItem("email")).toBe("x@y.com");
+    });
+    it("reads initial productionName from localStorage", () => {
+        localStorage.setItem("name", "FromStorage");
+        mockRows = [];
+        mockConfiguredRows = [];
+        const { result } = renderProvider();
+        expect(result.current.productionName).toBe("FromStorage");
+    });
+    it("persists reasonForRequest to localStorage on update", () => {
+        mockRows = [];
+        mockConfiguredRows = [];
+        const { result } = renderProvider();
+        act(() => result.current.setReasonForRequest("my reason"));
+        expect(localStorage.getItem("reasonForRequest")).toBe("my reason");
+    });
+});
+// ---------------------------------------------------------------------------
+// reasonForRequest
+// ---------------------------------------------------------------------------
+describe("RequestProvider — reasonForRequest", () => {
+    it("starts with empty reasonForRequest", () => {
+        mockRows = [];
+        mockConfiguredRows = [];
+        const { result } = renderProvider();
+        expect(result.current.reasonForRequest).toBe("");
+    });
+    it("updates reasonForRequest via setReasonForRequest", () => {
+        mockRows = [];
+        mockConfiguredRows = [];
+        const { result } = renderProvider();
+        act(() => result.current.setReasonForRequest("I need these for research"));
+        expect(result.current.reasonForRequest).toBe("I need these for research");
+    });
+    it("resets reasonForRequest on clearAll", () => {
+        mockRows = [];
+        mockConfiguredRows = [];
+        const { result } = renderProvider();
+        act(() => result.current.setReasonForRequest("some reason"));
+        act(() => result.current.clearAll());
+        expect(result.current.reasonForRequest).toBe("");
+    });
+});
+// ---------------------------------------------------------------------------
+// useRequest outside provider
+// ---------------------------------------------------------------------------
+describe("useRequest outside provider", () => {
+    it("throws when used outside a RequestProvider", () => {
+        expect(() => renderHook(() => useRequest())).toThrow("useRequest must be used within a RequestProvider");
+    });
+});

package/dist/tests/providers/RowProvider.test.d.ts

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

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

@@ -0,0 +1,110 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, expect, it, vi } from "vitest";
+import { renderHook } from "@testing-library/react";
+import { RowProvider, useRow } from "../../providers/RowProvider";
+import { createMockRow, mockStrippingLine } from "../testUtils";
+const mockUpdateRow = vi.fn();
+vi.mock("../../providers/RowsProvider", () => ({
+    useRows: () => ({
+        rows: [],
+        configuredRows: [],
+        setRows: vi.fn(),
+        updateRow: mockUpdateRow,
+        removeRow: vi.fn(),
+        generateAllFiles: vi.fn(),
+    }),
+}));
+function makeWrapper(row) {
+    return function Wrapper({ children }) {
+        return _jsx(RowProvider, { row: row, children: children });
+    };
+}
+// ---------------------------------------------------------------------------
+// validateBkPath
+// ---------------------------------------------------------------------------
+const VALID_PATH = "/LHCb/Collision16/Beam6500GeV-VeloClosed-MagDown/Real Data/Reco16/Stripping28r2/90000000/DIMUON.DST";
+describe("RowProvider — validateBkPath", () => {
+    it("returns true for a valid path when no stripping line is set", () => {
+        const row = createMockRow({ line: null });
+        const { result } = renderHook(() => useRow(), { wrapper: makeWrapper(row) });
+        expect(result.current.validateBkPath(VALID_PATH)).toBe(true);
+    });
+    it("returns true when path matches the line's stream and version", () => {
+        const row = createMockRow({ line: mockStrippingLine });
+        const { result } = renderHook(() => useRow(), { wrapper: makeWrapper(row) });
+        // fileName is "DIMUON.DST" → base is "dimuon", stream is "leptonic" → must match allstreams or stream name
+        // Actually DIMUON.DST fileName "DIMUON" doesn't match "leptonic"
+        // Let me check... The validation: ["allstreams", streamName].includes(fileName)
+        // streamName = "leptonic", fileName = "dimuon" → NOT a match
+        // Wait this might return false. Let me re-check the logic:
+        // validateBkPathsForLines checks: ["allstreams", streamName].includes(fileName)
+        // DIMUON.DST → fileName = "DIMUON.DST", fileName.split(".")[0].toLowerCase() = "dimuon"
+        // streamName = line.stream.toLowerCase() = "leptonic"
+        // ["allstreams", "leptonic"].includes("dimuon") → false
+        // So DIMUON.DST does NOT match Leptonic stream. Use ALLSTREAMS.DST instead.
+        const allstreamsPath = "/LHCb/Collision16/Beam6500GeV-VeloClosed-MagDown/Real Data/Reco16/Stripping28r2/90000000/ALLSTREAMS.DST";
+        expect(result.current.validateBkPath(allstreamsPath)).toBe(true);
+    });
+    it("returns false for a path with wrong stripping version", () => {
+        const row = createMockRow({ line: mockStrippingLine });
+        const { result } = renderHook(() => useRow(), { wrapper: makeWrapper(row) });
+        // mockStrippingLine has versions: ["28r2"], wrong version "21"
+        const wrongVersionAllstreams = "/LHCb/Collision16/Beam6500GeV-VeloClosed-MagDown/Real Data/Reco16/Stripping21/90000000/ALLSTREAMS.DST";
+        expect(result.current.validateBkPath(wrongVersionAllstreams)).toBe(false);
+    });
+    it("returns false for an invalid path format", () => {
+        const row = createMockRow({ line: mockStrippingLine });
+        const { result } = renderHook(() => useRow(), { wrapper: makeWrapper(row) });
+        expect(result.current.validateBkPath("not-a-valid-path")).toBe(false);
+    });
+    it("returns true for an ALLSTREAMS path matching the version", () => {
+        const row = createMockRow({ line: mockStrippingLine });
+        const { result } = renderHook(() => useRow(), { wrapper: makeWrapper(row) });
+        const allstreams = "/LHCb/Collision16/Beam6500GeV-VeloClosed-MagDown/Real Data/Reco16/Stripping28r2/90000000/ALLSTREAMS.DST";
+        expect(result.current.validateBkPath(allstreams)).toBe(true);
+    });
+    it("exposes the row from context", () => {
+        const row = createMockRow({ id: 42 });
+        const { result } = renderHook(() => useRow(), { wrapper: makeWrapper(row) });
+        expect(result.current.row.id).toBe(42);
+    });
+});
+// ---------------------------------------------------------------------------
+// updateBkPaths
+// ---------------------------------------------------------------------------
+describe("RowProvider — updateBkPaths", () => {
+    it("calls updateRow when updateBkPaths is invoked", () => {
+        const row = createMockRow({ line: mockStrippingLine });
+        const { result } = renderHook(() => useRow(), { wrapper: makeWrapper(row) });
+        const allstreams = "/LHCb/Collision16/Beam6500GeV-VeloClosed-MagDown/Real Data/Reco16/Stripping28r2/90000000/ALLSTREAMS.DST";
+        result.current.updateBkPaths([allstreams]);
+        expect(mockUpdateRow).toHaveBeenCalledOnce();
+    });
+    it("updateRow callback filters paths using validateBkPath", () => {
+        // Make mockUpdateRow actually invoke the callback so the inner lines are covered
+        mockUpdateRow.mockImplementation((_id, fn) => {
+            const fakeRow = {
+                id: 5,
+                decay: {},
+                dtt: null,
+                line: mockStrippingLine,
+                paths: [],
+                pathOptions: [],
+            };
+            fn(fakeRow);
+        });
+        const row = createMockRow({ line: mockStrippingLine });
+        const { result } = renderHook(() => useRow(), { wrapper: makeWrapper(row) });
+        const allstreams = "/LHCb/Collision16/Beam6500GeV-VeloClosed-MagDown/Real Data/Reco16/Stripping28r2/90000000/ALLSTREAMS.DST";
+        result.current.updateBkPaths([allstreams]);
+        expect(mockUpdateRow).toHaveBeenCalled();
+    });
+});
+// ---------------------------------------------------------------------------
+// useRow outside provider
+// ---------------------------------------------------------------------------
+describe("useRow outside provider", () => {
+    it("throws when used outside a RowProvider", () => {
+        expect(() => renderHook(() => useRow())).toThrow("useRow must be used within a RowProvider");
+    });
+});

package/dist/tests/providers/RowsProvider.test.d.ts

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

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

@@ -0,0 +1,84 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, expect, it } from "vitest";
+import { act, renderHook } from "@testing-library/react";
+import { RowsProvider, useRows } from "../../providers/RowsProvider";
+import { createMockDtt, createMockRow } from "../testUtils";
+function makeWrapper() {
+    return function Wrapper({ children }) {
+        return _jsx(RowsProvider, { children: children });
+    };
+}
+function renderProvider() {
+    return renderHook(() => useRows(), { wrapper: makeWrapper() });
+}
+describe("RowsProvider", () => {
+    it("starts with an empty rows list when localStorage has no rows", () => {
+        localStorage.removeItem("rows");
+        const { result } = renderProvider();
+        expect(result.current.rows).toEqual([]);
+    });
+    it("hydrates rows from localStorage on mount", () => {
+        const row = createMockRow({ id: 99 });
+        localStorage.setItem("rows", JSON.stringify([{ ...row, dtt: null }]));
+        const { result } = renderProvider();
+        expect(result.current.rows[0].id).toBe(99);
+        localStorage.removeItem("rows");
+    });
+    it("reconstructs Dtt from config when stored row has a dtt", () => {
+        const row = createMockRow({ id: 200, dtt: createMockDtt("StoredTree") });
+        localStorage.setItem("rows", JSON.stringify([row]));
+        const { result } = renderProvider();
+        expect(result.current.rows[0].dtt).not.toBeNull();
+        localStorage.removeItem("rows");
+    });
+    it("updateRow modifies the matching row", () => {
+        localStorage.removeItem("rows");
+        const { result } = renderProvider();
+        act(() => result.current.setRows([createMockRow({ id: 1 })]));
+        act(() => result.current.updateRow(1, (r) => ({ ...r, id: 99 })));
+        expect(result.current.rows[0].id).toBe(99);
+    });
+    it("updateRow does not modify rows with a different id", () => {
+        localStorage.removeItem("rows");
+        const { result } = renderProvider();
+        act(() => result.current.setRows([createMockRow({ id: 1 }), createMockRow({ id: 2 })]));
+        act(() => result.current.updateRow(1, (r) => ({ ...r, id: 99 })));
+        expect(result.current.rows[1].id).toBe(2);
+    });
+    it("removeRow filters out the row with the given id", () => {
+        localStorage.removeItem("rows");
+        const { result } = renderProvider();
+        act(() => result.current.setRows([createMockRow({ id: 1 }), createMockRow({ id: 2 })]));
+        act(() => result.current.removeRow(1));
+        expect(result.current.rows).toHaveLength(1);
+        expect(result.current.rows[0].id).toBe(2);
+    });
+    it("configuredRows contains only rows with a dtt", () => {
+        localStorage.removeItem("rows");
+        const { result } = renderProvider();
+        act(() => result.current.setRows([createMockRow({ id: 1, dtt: null }), createMockRow({ id: 2, dtt: createMockDtt() })]));
+        expect(result.current.configuredRows).toHaveLength(1);
+        expect(result.current.configuredRows[0].id).toBe(2);
+    });
+    it("generateAllFiles returns one file per configured row plus info.yaml", () => {
+        localStorage.removeItem("rows");
+        const { result } = renderProvider();
+        act(() => result.current.setRows([
+            createMockRow({ id: 1, dtt: createMockDtt("TreeA") }),
+            createMockRow({ id: 2, dtt: createMockDtt("TreeB") }),
+        ]));
+        const files = result.current.generateAllFiles();
+        // 2 dtt files + 1 info.yaml
+        expect(files).toHaveLength(3);
+    });
+    it("persists rows to localStorage when rows change", () => {
+        localStorage.removeItem("rows");
+        const { result } = renderProvider();
+        act(() => result.current.setRows([createMockRow({ id: 7 })]));
+        const stored = JSON.parse(localStorage.getItem("rows") ?? "[]");
+        expect(stored[0].id).toBe(7);
+    });
+    it("throws when useRows is used outside the provider", () => {
+        expect(() => renderHook(() => useRows())).toThrow("useRows must be used within a RowsProvider");
+    });
+});

package/dist/tests/providers/WizardConfigProvider.test.d.ts

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