lhcb-ntuple-wizard-test 2.0.7 → 2.2.0

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

@@ -0,0 +1,376 @@
+import { describe, expect, it } from "vitest";
+import Dtt from "../../models/dtt";
+import { TupleTool } from "../../models/tupleTool";
+import { mockBranchItems, mockToolMetadata } from "../testUtils";
+const DEFAULT_TOOLS = [
+    "TupleToolKinematic",
+    "TupleToolPid",
+    "TupleToolANNPID",
+    "TupleToolGeometry",
+    "TupleToolEventInfo",
+];
+function createDtt(name = "MyTree") {
+    return Dtt.create("[B+ -> ${head} ${k} ${mup} ${mum}]cc", mockBranchItems, [], name, mockToolMetadata);
+}
+describe("Dtt", () => {
+    describe("create()", () => {
+        it("creates a Dtt with all default tools", () => {
+            const dtt = createDtt();
+            for (const tool of DEFAULT_TOOLS) {
+                expect(dtt.toolExists(TupleTool.fromString(tool))).toBe(true);
+            }
+        });
+        it("creates branches from the branch map", () => {
+            const dtt = createDtt();
+            expect(dtt.config.branches).toHaveProperty("head");
+            expect(dtt.config.branches).toHaveProperty("k");
+            expect(dtt.config.branches).toHaveProperty("mup");
+            expect(dtt.config.branches).toHaveProperty("mum");
+        });
+        it("assigns correct particle to each branch", () => {
+            const dtt = createDtt();
+            expect(dtt.config.branches["head"].particle).toBe("B+");
+            expect(dtt.config.branches["k"].particle).toBe("K+");
+            expect(dtt.config.branches["mup"].particle).toBe("mu+");
+            expect(dtt.config.branches["mum"].particle).toBe("mu-");
+        });
+        it("stores the descriptor template", () => {
+            const template = "[B+ -> ${head} ${k} ${mup} ${mum}]cc";
+            const dtt = Dtt.create(template, mockBranchItems, [], "MyTree", mockToolMetadata);
+            expect(dtt.config.descriptorTemplate).toBe(template);
+        });
+        it("sets input to first element when inputs list is non-empty", () => {
+            const input = "/Event/Phys/TestLine/Particles";
+            const dtt = Dtt.create("t", mockBranchItems, [input], "MyTree", mockToolMetadata);
+            expect(dtt.config.input).toBe(input);
+        });
+        it("leaves input undefined when inputs list is empty", () => {
+            const dtt = createDtt();
+            expect(dtt.config.input).toBeUndefined();
+        });
+        it("initializes with empty groups", () => {
+            const dtt = createDtt();
+            expect(dtt.config.groups).toEqual({});
+        });
+        it("applies default tool params from metadata", () => {
+            const dtt = createDtt();
+            expect(dtt.config.tools["TupleToolKinematic"]["Verbose"].value).toBe(false);
+        });
+    });
+    describe("withAddedTool()", () => {
+        it("adds a tool to global tools", () => {
+            const dtt = createDtt();
+            const newTool = new TupleTool("TupleToolL0Data", "");
+            const updated = dtt.withAddedTool(newTool);
+            expect(updated.toolExists(newTool)).toBe(true);
+        });
+        it("is immutable — original not modified", () => {
+            const dtt = createDtt();
+            const newTool = new TupleTool("TupleToolL0Data", "");
+            dtt.withAddedTool(newTool);
+            expect(dtt.toolExists(newTool)).toBe(false);
+        });
+        it("returns same instance when tool already exists", () => {
+            const dtt = createDtt();
+            const existingTool = TupleTool.fromString("TupleToolKinematic");
+            const updated = dtt.withAddedTool(existingTool);
+            expect(updated).toBe(dtt);
+        });
+        it("adds tool to a specific branch", () => {
+            const dtt = createDtt();
+            const newTool = new TupleTool("TupleToolL0Data", "");
+            const updated = dtt.withAddedTool(newTool, ["head"]);
+            expect(updated.toolExists(newTool, ["head"])).toBe(true);
+            // global tools should not be affected
+            expect(updated.toolExists(newTool)).toBe(false);
+        });
+        it("adds tool to a group when multiple branches specified", () => {
+            const dtt = createDtt();
+            const newTool = new TupleTool("TupleToolL0Data", "");
+            const updated = dtt.withAddedTool(newTool, ["head", "k"]);
+            expect(updated.toolExists(newTool, ["head", "k"])).toBe(true);
+        });
+        it("creates group with correct particles", () => {
+            const dtt = createDtt();
+            const newTool = new TupleTool("TupleToolL0Data", "");
+            const updated = dtt.withAddedTool(newTool, ["head", "k"]);
+            const particles = updated.getParticlesByBranchId(["head", "k"]);
+            expect(particles).toContain("B+");
+            expect(particles).toContain("K+");
+        });
+    });
+    describe("withRemovedTool()", () => {
+        it("removes a tool from global tools", () => {
+            const dtt = createDtt();
+            const tool = TupleTool.fromString("TupleToolKinematic");
+            const updated = dtt.withRemovedTool(tool);
+            expect(updated.toolExists(tool)).toBe(false);
+        });
+        it("is immutable — original not modified", () => {
+            const dtt = createDtt();
+            const tool = TupleTool.fromString("TupleToolKinematic");
+            dtt.withRemovedTool(tool);
+            expect(dtt.toolExists(tool)).toBe(true);
+        });
+        it("removes tool from a specific branch", () => {
+            const dtt = createDtt();
+            const newTool = new TupleTool("TupleToolL0Data", "");
+            const withTool = dtt.withAddedTool(newTool, ["head"]);
+            const withoutTool = withTool.withRemovedTool(newTool, ["head"]);
+            expect(withoutTool.toolExists(newTool, ["head"])).toBe(false);
+        });
+        it("only removes from the specified branch, not global", () => {
+            const dtt = createDtt();
+            const tool = TupleTool.fromString("TupleToolKinematic");
+            const updated = dtt.withRemovedTool(tool, ["head"]);
+            // Global tools should still contain it
+            expect(updated.toolExists(tool)).toBe(true);
+        });
+    });
+    describe("withUpdatedToolParam()", () => {
+        it("updates a bool parameter value", () => {
+            const dtt = createDtt();
+            const tool = TupleTool.fromString("TupleToolKinematic");
+            const updated = dtt.withUpdatedToolParam([], tool, "Verbose", true);
+            expect(updated.config.tools["TupleToolKinematic"]["Verbose"].value).toBe(true);
+        });
+        it("is immutable — original not modified", () => {
+            const dtt = createDtt();
+            const tool = TupleTool.fromString("TupleToolKinematic");
+            dtt.withUpdatedToolParam([], tool, "Verbose", true);
+            expect(dtt.config.tools["TupleToolKinematic"]["Verbose"].value).toBe(false);
+        });
+        it("preserves other params when updating one", () => {
+            const dtt = createDtt();
+            const tool = TupleTool.fromString("TupleToolPid");
+            const updated = dtt.withUpdatedToolParam([], tool, "Verbose", true);
+            // TupleToolKinematic should still have default Verbose
+            expect(updated.config.tools["TupleToolKinematic"]["Verbose"].value).toBe(false);
+        });
+    });
+    describe("withName()", () => {
+        it("sets name with DecayTreeTuple/ prefix", () => {
+            const dtt = createDtt();
+            const updated = dtt.withName("MyDecayTree");
+            expect(updated.config.name).toBe("DecayTreeTuple/MyDecayTree");
+        });
+        it("strips non-word characters from name", () => {
+            const dtt = createDtt();
+            const updated = dtt.withName("My Decay-Tree!");
+            expect(updated.config.name).toBe("DecayTreeTuple/MyDecayTree");
+        });
+        it("is immutable — original not modified", () => {
+            const dtt = createDtt();
+            const originalName = dtt.config.name;
+            dtt.withName("NewName");
+            expect(dtt.config.name).toBe(originalName);
+        });
+    });
+    describe("withInputFromLine()", () => {
+        it("constructs the correct input path from a stripping line", () => {
+            const dtt = createDtt();
+            const line = {
+                line: "StrippingBuToKJpsiee2Line",
+                stream: "Leptonic",
+                versions: ["28r2"],
+            };
+            const updated = dtt.withInputFromLine(line);
+            expect(updated.config.input).toBe("/Event/Leptonic/Phys/BuToKJpsiee2Line/Particles");
+        });
+        it("is immutable — original not modified", () => {
+            const dtt = createDtt();
+            const line = { line: "StrippingTestLine", stream: "Charm", versions: [] };
+            dtt.withInputFromLine(line);
+            expect(dtt.config.input).toBeUndefined();
+        });
+    });
+    describe("getName()", () => {
+        it("returns the part after '/' in the name", () => {
+            const dtt = createDtt().withName("MyTree");
+            expect(dtt.getName()).toBe("MyTree");
+        });
+        it("returns empty string when name is not set", () => {
+            const dtt = new Dtt({ tools: {}, branches: {}, groups: {} }, mockToolMetadata);
+            expect(dtt.getName()).toBe("");
+        });
+        it("returns the whole name if no slash present", () => {
+            const dtt = new Dtt({ tools: {}, branches: {}, groups: {}, name: "MyTree" }, mockToolMetadata);
+            expect(dtt.getName()).toBe("MyTree");
+        });
+    });
+    describe("listTools()", () => {
+        it("returns a TupleTool instance for each global tool", () => {
+            const dtt = createDtt();
+            const tools = dtt.listTools();
+            expect(tools).toHaveLength(DEFAULT_TOOLS.length);
+            tools.forEach((t) => expect(t).toBeInstanceOf(TupleTool));
+        });
+        it("returns empty array when DTT has no tools", () => {
+            const dtt = new Dtt({ tools: {}, branches: {}, groups: {} }, mockToolMetadata);
+            expect(dtt.listTools()).toEqual([]);
+        });
+        it("returns branch-specific tools when branch is specified", () => {
+            const dtt = createDtt();
+            const newTool = new TupleTool("TupleToolL0Data", "");
+            const updated = dtt.withAddedTool(newTool, ["head"]);
+            const branchTools = updated.listTools(["head"]);
+            expect(branchTools.some((t) => t.equals(newTool))).toBe(true);
+        });
+    });
+    describe("toolExists()", () => {
+        it("returns true for an existing global tool", () => {
+            const dtt = createDtt();
+            expect(dtt.toolExists(TupleTool.fromString("TupleToolKinematic"))).toBe(true);
+        });
+        it("returns false for a non-existing tool", () => {
+            const dtt = createDtt();
+            expect(dtt.toolExists(TupleTool.fromString("TupleToolL0Data"))).toBe(false);
+        });
+        it("returns true for a branch tool in the correct branch", () => {
+            const dtt = createDtt();
+            const newTool = new TupleTool("TupleToolL0Data", "");
+            const updated = dtt.withAddedTool(newTool, ["head"]);
+            expect(updated.toolExists(newTool, ["head"])).toBe(true);
+        });
+        it("returns false for a branch tool checked in the wrong branch", () => {
+            const dtt = createDtt();
+            const newTool = new TupleTool("TupleToolL0Data", "");
+            const updated = dtt.withAddedTool(newTool, ["head"]);
+            expect(updated.toolExists(newTool, ["k"])).toBe(false);
+        });
+    });
+    describe("getGroupsWithTools()", () => {
+        it("returns empty array when no groups have tools", () => {
+            const dtt = createDtt();
+            expect(dtt.getGroupsWithTools()).toEqual([]);
+        });
+        it("returns the group key when a group has tools", () => {
+            const dtt = createDtt();
+            const tool = new TupleTool("TupleToolL0Data", "");
+            const updated = dtt.withAddedTool(tool, ["head", "k"]);
+            expect(updated.getGroupsWithTools()).toContain("head,k");
+        });
+        it("does not return empty groups", () => {
+            const dtt = createDtt();
+            // Touch a group (creates it empty) then check
+            dtt.getParticlesByBranchId(["head", "k"]);
+            expect(dtt.getGroupsWithTools()).toEqual([]);
+        });
+    });
+    describe("getGroupsThatIncludeBranch()", () => {
+        it("returns groups containing the specified branch", () => {
+            const dtt = createDtt();
+            const tool = new TupleTool("TupleToolL0Data", "");
+            const updated = dtt.withAddedTool(tool, ["head", "k"]);
+            expect(updated.getGroupsThatIncludeBranch(["head"])).toContain("head,k");
+        });
+        it("returns empty when no groups contain the specified branch", () => {
+            const dtt = createDtt();
+            expect(dtt.getGroupsThatIncludeBranch(["head"])).toEqual([]);
+        });
+    });
+    describe("toSavedConfig() / fromSavedConfig() roundtrip", () => {
+        it("skips unknown params when loading tool config", () => {
+            const dtt = createDtt();
+            const saved = dtt.toSavedConfig();
+            // Add a param that doesn't exist in TupleToolKinematic's interface
+            const kinemEntry = saved.tools.find((t) => "TupleToolKinematic" in t);
+            kinemEntry["TupleToolKinematic"]["UnknownParam"] = true;
+            const loaded = Dtt.fromSavedConfig(saved, mockToolMetadata);
+            expect(loaded.toolExists(TupleTool.fromString("TupleToolKinematic"))).toBe(true);
+            expect(loaded.config.tools["TupleToolKinematic"]["UnknownParam"]).toBeUndefined();
+        });
+        it("preserves groups after roundtrip through fromSavedConfig", () => {
+            const dtt = createDtt().withAddedTool(new TupleTool("TupleToolL0Data", ""), ["head", "k"]);
+            const saved = dtt.toSavedConfig();
+            const loaded = Dtt.fromSavedConfig(saved, mockToolMetadata);
+            expect(loaded.toolExists(new TupleTool("TupleToolL0Data", ""), ["head", "k"])).toBe(true);
+        });
+        it("preserves the descriptor template", () => {
+            const template = "[B+ -> ${head} ${k} ${mup} ${mum}]cc";
+            const dtt = Dtt.create(template, mockBranchItems, [], "MyTree", mockToolMetadata);
+            const saved = dtt.toSavedConfig();
+            expect(saved.descriptorTemplate).toBe(template);
+        });
+        it("saves tool params as plain values, not ToolParam objects", () => {
+            const dtt = createDtt().withUpdatedToolParam([], TupleTool.fromString("TupleToolKinematic"), "Verbose", true);
+            const saved = dtt.toSavedConfig();
+            const kinemEntry = saved.tools.find((t) => "TupleToolKinematic" in t);
+            expect(kinemEntry?.["TupleToolKinematic"]?.["Verbose"]).toBe(true);
+        });
+        it("reconstructs global tools after roundtrip", () => {
+            const dtt = createDtt();
+            const saved = dtt.toSavedConfig();
+            const loaded = Dtt.fromSavedConfig(saved, mockToolMetadata);
+            for (const toolName of DEFAULT_TOOLS) {
+                expect(loaded.toolExists(TupleTool.fromString(toolName))).toBe(true);
+            }
+        });
+        it("preserves branch particle assignments after roundtrip", () => {
+            const dtt = createDtt();
+            const saved = dtt.toSavedConfig();
+            const loaded = Dtt.fromSavedConfig(saved, mockToolMetadata);
+            expect(loaded.config.branches["head"].particle).toBe("B+");
+            expect(loaded.config.branches["k"].particle).toBe("K+");
+        });
+        it("skips tools not found in metadata during load", () => {
+            const dtt = createDtt();
+            const saved = dtt.toSavedConfig();
+            // Add an unknown tool entry to the saved config
+            saved.tools.push({ UnknownTool: { SomeParam: true } });
+            const loaded = Dtt.fromSavedConfig(saved, mockToolMetadata);
+            expect(loaded.toolExists(TupleTool.fromString("UnknownTool"))).toBe(false);
+        });
+    });
+    describe("withConfig()", () => {
+        it("returns a new Dtt with the supplied config", () => {
+            const dtt = createDtt();
+            const newConfig = { ...dtt.config, name: "DecayTreeTuple/NewName" };
+            const newDtt = dtt.withConfig(newConfig);
+            expect(newDtt.getName()).toBe("NewName");
+        });
+    });
+    describe("toSavedConfig() with groups", () => {
+        it("includes group tools in the saved config", () => {
+            const dtt = createDtt().withAddedTool(new TupleTool("TupleToolKinematic", ""), ["head", "k"]);
+            const saved = dtt.toSavedConfig();
+            const groupKey = "head,k";
+            expect(saved.groups).toHaveProperty(groupKey);
+            expect(saved.groups[groupKey].tools).toHaveLength(1);
+        });
+    });
+    describe("pruneGroups()", () => {
+        it("removes groups that have no tools", () => {
+            const dtt = createDtt();
+            // Add a group then remove the tool from it
+            const withGroup = dtt.withAddedTool(new TupleTool("TupleToolKinematic", ""), ["head", "k"]);
+            const withRemovedTool = withGroup.withRemovedTool(new TupleTool("TupleToolKinematic", ""), ["head", "k"]);
+            // After pruning (triggered by getToolsByBranch), the group should be gone
+            const tools = withRemovedTool.getToolsByBranch(["head", "k"]);
+            expect(Object.keys(tools)).toHaveLength(0);
+        });
+        it("keeps groups that still have tools", () => {
+            const dtt = createDtt();
+            const withGroup = dtt.withAddedTool(new TupleTool("TupleToolKinematic", ""), ["head", "k"]);
+            const tools = withGroup.getToolsByBranch(["head", "k"]);
+            expect("TupleToolKinematic").toEqual(Object.keys(tools)[0]);
+        });
+    });
+    describe("getBranchTools()", () => {
+        it("returns tool names for global branch (no branch arg)", () => {
+            const dtt = createDtt();
+            const tools = dtt.getBranchTools();
+            expect(tools).toContain("TupleToolKinematic");
+        });
+        it("returns tool names for a specific branch", () => {
+            const dtt = createDtt().withAddedTool(new TupleTool("TupleToolL0Data", ""), ["head"]);
+            const tools = dtt.getBranchTools(["head"]);
+            expect(tools).toContain("TupleToolL0Data");
+        });
+        it("returns an empty array for a group with no tools", () => {
+            const dtt = createDtt();
+            const tools = dtt.getBranchTools(["head", "k"]);
+            expect(tools).toHaveLength(0);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,80 @@
+import { describe, expect, it } from "vitest";
+import { TupleTool } from "../../models/tupleTool";
+describe("TupleTool", () => {
+    describe("constructor", () => {
+        it("stores class and name", () => {
+            const tool = new TupleTool("TupleToolKinematic", "myKinematic");
+            expect(tool.class).toBe("TupleToolKinematic");
+            expect(tool.name).toBe("myKinematic");
+        });
+        it("stores class with empty name", () => {
+            const tool = new TupleTool("TupleToolKinematic", "");
+            expect(tool.class).toBe("TupleToolKinematic");
+            expect(tool.name).toBe("");
+        });
+    });
+    describe("toString()", () => {
+        it("returns 'Class/name' when name is set", () => {
+            const tool = new TupleTool("TupleToolKinematic", "myKinematic");
+            expect(tool.toString()).toBe("TupleToolKinematic/myKinematic");
+        });
+        it("returns just class when name is empty", () => {
+            const tool = new TupleTool("TupleToolKinematic", "");
+            expect(tool.toString()).toBe("TupleToolKinematic");
+        });
+    });
+    describe("fromString()", () => {
+        it("parses 'Class/name' string", () => {
+            const tool = TupleTool.fromString("TupleToolKinematic/myKinematic");
+            expect(tool.class).toBe("TupleToolKinematic");
+            expect(tool.name).toBe("myKinematic");
+        });
+        it("parses class-only string", () => {
+            const tool = TupleTool.fromString("TupleToolKinematic");
+            expect(tool.class).toBe("TupleToolKinematic");
+            expect(tool.name).toBe("");
+        });
+        it("handles class with nested slashes (only splits on first slash)", () => {
+            const tool = TupleTool.fromString("LoKi__Hybrid__TupleTool/myLoki");
+            expect(tool.class).toBe("LoKi__Hybrid__TupleTool");
+            expect(tool.name).toBe("myLoki");
+        });
+    });
+    describe("equals()", () => {
+        it("returns true for identical tools with name", () => {
+            const a = new TupleTool("TupleToolKinematic", "myKinematic");
+            const b = new TupleTool("TupleToolKinematic", "myKinematic");
+            expect(a.equals(b)).toBe(true);
+        });
+        it("returns true for identical tools without name", () => {
+            const a = new TupleTool("TupleToolKinematic", "");
+            const b = new TupleTool("TupleToolKinematic", "");
+            expect(a.equals(b)).toBe(true);
+        });
+        it("returns false for different class", () => {
+            const a = new TupleTool("TupleToolKinematic", "");
+            const b = new TupleTool("TupleToolPid", "");
+            expect(a.equals(b)).toBe(false);
+        });
+        it("returns false for different name", () => {
+            const a = new TupleTool("TupleToolKinematic", "myKinematic");
+            const b = new TupleTool("TupleToolKinematic", "otherKinematic");
+            expect(a.equals(b)).toBe(false);
+        });
+        it("returns false when one has name and other does not", () => {
+            const a = new TupleTool("TupleToolKinematic", "myKinematic");
+            const b = new TupleTool("TupleToolKinematic", "");
+            expect(a.equals(b)).toBe(false);
+        });
+    });
+    describe("fromString / toString roundtrip", () => {
+        it("round-trips a tool with name", () => {
+            const original = "TupleToolL0Data/myL0Data";
+            expect(TupleTool.fromString(original).toString()).toBe(original);
+        });
+        it("round-trips a tool without name", () => {
+            const original = "TupleToolGeometry";
+            expect(TupleTool.fromString(original).toString()).toBe(original);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,123 @@
+import { describe, expect, it } from "vitest";
+import { YamlFile } from "../../models/yamlFile";
+import Dtt from "../../models/dtt";
+import yaml from "js-yaml";
+import { createMockRow, mockBranchItems, mockDecay, mockMetadata, mockStrippingLine, mockToolMetadata, } from "../testUtils";
+function createNamedDtt(name) {
+    return Dtt.create("[B+ -> ${head} ${k} ${mup} ${mum}]cc", mockBranchItems, [], name, mockToolMetadata).withName(name);
+}
+describe("YamlFile", () => {
+    describe("constructor", () => {
+        it("sanitizes the filename", () => {
+            const file = new YamlFile("../unsafe/../file.yaml", "content");
+            // Path traversal characters are removed
+            expect(file.name).not.toContain("..");
+            expect(file.name).not.toContain("/");
+        });
+        it("stores the content unchanged", () => {
+            const content = "tools:\n  - TupleToolKinematic\n";
+            const file = new YamlFile("test.yaml", content);
+            expect(file.content).toBe(content);
+        });
+    });
+    describe("fromDtt()", () => {
+        it("uses the DTT name as the filename", () => {
+            const dtt = createNamedDtt("MyTree");
+            const file = YamlFile.fromDtt(dtt);
+            expect(file.name).toBe("MyTree.yaml");
+        });
+        it("produces valid YAML content", () => {
+            const dtt = createNamedDtt("MyTree");
+            const file = YamlFile.fromDtt(dtt);
+            expect(() => yaml.load(file.content)).not.toThrow();
+        });
+        it("YAML content contains the descriptor template", () => {
+            const template = "[B+ -> ${head} ${k} ${mup} ${mum}]cc";
+            const dtt = Dtt.create(template, mockBranchItems, [], "MyTree", mockToolMetadata).withName("MyTree");
+            const file = YamlFile.fromDtt(dtt);
+            const parsed = yaml.load(file.content);
+            expect(parsed.descriptorTemplate).toBe(template);
+        });
+        it("YAML content lists the default tools", () => {
+            const dtt = createNamedDtt("MyTree");
+            const file = YamlFile.fromDtt(dtt);
+            const parsed = yaml.load(file.content);
+            const toolNames = (parsed.tools ?? []).map((t) => Object.keys(t)[0]);
+            expect(toolNames).toContain("TupleToolKinematic");
+            expect(toolNames).toContain("TupleToolPid");
+        });
+        it("YAML content includes branch definitions", () => {
+            const dtt = createNamedDtt("MyTree");
+            const file = YamlFile.fromDtt(dtt);
+            const parsed = yaml.load(file.content);
+            expect(parsed.branches).toHaveProperty("head");
+            expect(parsed.branches).toHaveProperty("k");
+        });
+    });
+    describe("createInfoYaml()", () => {
+        const VALID_PATH = "/LHCb/Collision16/Beam6500GeV-VeloClosed-MagDown/Real Data/Reco16/Stripping28r2/90000000/DIMUON.DST";
+        function createRowWithPath(id, name, paths) {
+            return createMockRow({
+                id,
+                decay: mockDecay,
+                dtt: createNamedDtt(name),
+                line: mockStrippingLine,
+                paths,
+            });
+        }
+        it("produces a file named 'info.yaml'", () => {
+            const file = YamlFile.createInfoYaml([], mockMetadata);
+            expect(file.name).toBe("info.yaml");
+        });
+        it("includes the DaVinci application version in defaults", () => {
+            const file = YamlFile.createInfoYaml([], mockMetadata);
+            const parsed = yaml.load(file.content);
+            expect(parsed.defaults?.application).toContain("DaVinci");
+            expect(parsed.defaults?.application).toContain("v45r7");
+        });
+        it("includes standard defaults", () => {
+            const file = YamlFile.createInfoYaml([], mockMetadata);
+            const parsed = yaml.load(file.content);
+            expect(parsed.defaults?.wg).toBe("OpenData");
+            expect(parsed.defaults?.automatically_configure).toBe(true);
+        });
+        it("creates a job entry for each unique path", () => {
+            const row = createRowWithPath(0, "MyTree", [VALID_PATH]);
+            const file = YamlFile.createInfoYaml([row], mockMetadata);
+            const parsed = yaml.load(file.content);
+            expect(parsed.job0?.input?.bk_query).toBe(VALID_PATH);
+        });
+        it("includes the DTT filename in the job options", () => {
+            const row = createRowWithPath(0, "MyTree", [VALID_PATH]);
+            const file = YamlFile.createInfoYaml([row], mockMetadata);
+            const parsed = yaml.load(file.content);
+            expect(parsed.job0?.options).toContain("MyTree");
+        });
+        it("skips rows without a DTT", () => {
+            const row = createMockRow({ id: 0, paths: [VALID_PATH], dtt: null });
+            const file = YamlFile.createInfoYaml([row], mockMetadata);
+            const parsed = yaml.load(file.content);
+            expect(Object.keys(parsed)).not.toContain("job0");
+        });
+        it("merges multiple DTTs for the same path into one job", () => {
+            const row1 = createRowWithPath(0, "TreeA", [VALID_PATH]);
+            const row2 = createRowWithPath(1, "TreeB", [VALID_PATH]);
+            const file = YamlFile.createInfoYaml([row1, row2], mockMetadata);
+            const parsed = yaml.load(file.content);
+            expect(parsed.job0?.options).toHaveLength(2);
+        });
+        it("adds root_in_tes for MDST paths", () => {
+            const mdstPath = "/LHCb/Collision16/Beam6500GeV-VeloClosed-MagDown/Real Data/Reco16/Stripping28r2/90000000/DIMUON.MDST";
+            const row = createRowWithPath(0, "MyTree", [mdstPath]);
+            const file = YamlFile.createInfoYaml([row], mockMetadata);
+            const parsed = yaml.load(file.content);
+            expect(parsed.job0?.root_in_tes).toContain("Leptonic");
+        });
+        it("does not add root_in_tes for non-MDST paths", () => {
+            const row = createRowWithPath(0, "MyTree", [VALID_PATH]);
+            const file = YamlFile.createInfoYaml([row], mockMetadata);
+            const parsed = yaml.load(file.content);
+            expect(parsed.job0?.root_in_tes).toBeUndefined();
+        });
+    });
+});

package/dist/tests/pages/DecaySearchPage.test.d.ts

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