laneyard 0.1.0

package/dist/tests/git/workspace.test.js

@@ -0,0 +1,66 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { Workspace } from "../../src/git/workspace.js";
+import { commitTo, makeOriginRepo, tmpDir } from "../fixtures/repos.js";
+describe("Workspace", () => {
+    it("clones on first access then declares itself ready", async () => {
+        const origin = await makeOriginRepo({ "README.md": "hello" });
+        const ws = new Workspace(join(await tmpDir(), "p"), origin);
+        expect(await ws.exists()).toBe(false);
+        await ws.prepare("main");
+        expect(await ws.exists()).toBe(true);
+        expect(await readFile(join(ws.path, "README.md"), "utf8")).toBe("hello");
+    }, 30_000);
+    it("fetches new commits on the next run", async () => {
+        const origin = await makeOriginRepo({ "a.txt": "v1" });
+        const ws = new Workspace(join(await tmpDir(), "p"), origin);
+        await ws.prepare("main");
+        const sha = await commitTo(origin, "a.txt", "v2");
+        await ws.prepare("main");
+        expect(await readFile(join(ws.path, "a.txt"), "utf8")).toBe("v2");
+        expect(await ws.headSha()).toBe(sha);
+    }, 30_000);
+    it("refuses to prepare over uncommitted changes", async () => {
+        const origin = await makeOriginRepo({ "a.txt": "v1" });
+        const ws = new Workspace(join(await tmpDir(), "p"), origin);
+        await ws.prepare("main");
+        await writeFile(join(ws.path, "a.txt"), "edited by hand", "utf8");
+        expect(await ws.isDirty()).toBe(true);
+        await expect(ws.prepare("main")).rejects.toThrow(/uncommitted/i);
+    }, 30_000);
+    it("doesn't declare itself dirty for untracked files left by a build", async () => {
+        const origin = await makeOriginRepo({ "a.txt": "v1" });
+        const ws = new Workspace(join(await tmpDir(), "p"), origin);
+        await ws.prepare("main");
+        // What a real run produces: fastlane rewrites its README, the build outputs a binary.
+        await writeFile(join(ws.path, "README-fastlane.md"), "generated", "utf8");
+        expect(await ws.isDirty()).toBe(false);
+        // And the next run must be able to prepare the workspace.
+        await expect(ws.prepare("main")).resolves.toMatch(/^[0-9a-f]{40}$/);
+    }, 30_000);
+    it("fails readably on an unknown branch", async () => {
+        const origin = await makeOriginRepo({ "a.txt": "v1" });
+        const ws = new Workspace(join(await tmpDir(), "p"), origin);
+        await expect(ws.prepare("does-not-exist")).rejects.toThrow(/does-not-exist/);
+    }, 30_000);
+    it("clones on demand without switching branch", async () => {
+        const origin = await makeOriginRepo({ "laneyard.yml": "runtime: system\n" });
+        const ws = new Workspace(join(await tmpDir(), "p"), origin);
+        await ws.ensureCloned();
+        expect(await ws.exists()).toBe(true);
+        // Idempotent: a second call redoes nothing and doesn't throw.
+        await ws.ensureCloned();
+        expect(await ws.exists()).toBe(true);
+    }, 30_000);
+    it("never copies the repository URL into an error message", async () => {
+        // An HTTPS URL can carry a token; these messages end up in the run's log.
+        const secret = "https://user:ghp_TRESSECRET@example.invalid/m/demo.git";
+        const ws = new Workspace(join(await tmpDir(), "p"), secret);
+        await expect(ws.prepare("main")).rejects.toThrow();
+        await ws.prepare("main").catch((err) => {
+            expect(err.message).not.toContain("ghp_TRESSECRET");
+            expect(err.message).toContain("<repository>");
+        });
+    }, 30_000);
+});

package/dist/tests/heuristics/error-summary.test.js

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { summarizeFailure } from "../../src/heuristics/error-summary.js";
+/** Output tail observed on a real failed run, ANSI sequences included. */
+const REAL_TAIL = [
+    "[13:19:32]: Called from Fastfile at line 7",
+    '[13:19:32]:  => 7:\t  UI.user_error!("code signature rejected by the keychain")',
+    "[13:19:32]: fastlane finished with errors",
+    "[!] code signature rejected by the keychain",
+].join("\n");
+describe("summarizeFailure", () => {
+    it("keeps the cause marked by fastlane, without ANSI or marker", () => {
+        expect(summarizeFailure(REAL_TAIL, 1)).toBe("code signature rejected by the keychain");
+    });
+    it("discards the generic closing message, which teaches nothing", () => {
+        const log = "[13:19:32]: Compiling\n[13:19:32]: fastlane finished with errors";
+        expect(summarizeFailure(log, 1)).not.toMatch(/finished with errors/);
+    });
+    it("falls back to a line mentioning an error when the marker is missing", () => {
+        const log = "[10:00:00]: Compiling\n[10:00:01]: error: no signing certificate found\n[10:00:02]: bye";
+        expect(summarizeFailure(log, 65)).toBe("error: no signing certificate found");
+    });
+    it("falls back to the exit code when the output teaches nothing", () => {
+        expect(summarizeFailure("[10:00:00]: all good", 65)).toBe("fastlane stopped with exit code 65");
+    });
+    it("stays readable when the run produced no output", () => {
+        expect(summarizeFailure("", null)).toBe("The run failed with no usable message");
+    });
+    it("truncates an oversized cause rather than flooding the list", () => {
+        expect(summarizeFailure(`[!] ${"x".repeat(900)}`, 1)).toHaveLength(500);
+    });
+});

package/dist/tests/logs/store.test.js

@@ -0,0 +1,38 @@
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { LogStore } from "../../src/logs/store.js";
+import { tmpDir } from "../fixtures/repos.js";
+describe("LogStore", () => {
+    it("writes and reads back in full", async () => {
+        const store = new LogStore(await tmpDir("laneyard-logs-"));
+        const w = await store.open(1);
+        await w.append("first line\n");
+        await w.append("second line\n");
+        await w.close();
+        expect(await store.read(1)).toBe("first line\nsecond line\n");
+    });
+    it("reads back from a byte offset", async () => {
+        const store = new LogStore(await tmpDir("laneyard-logs-"));
+        const w = await store.open(2);
+        await w.append("abcdef");
+        await w.close();
+        expect(await store.read(2, 3)).toBe("def");
+    });
+    it("exposes the current offset after every write", async () => {
+        const store = new LogStore(await tmpDir("laneyard-logs-"));
+        const w = await store.open(3);
+        expect(w.offset).toBe(0);
+        await w.append("hüllo"); // 6 bytes in UTF-8, not 5
+        expect(w.offset).toBe(6);
+        await w.close();
+    });
+    it("returns an empty string for a run with no log", async () => {
+        const store = new LogStore(await tmpDir("laneyard-logs-"));
+        expect(await store.read(999)).toBe("");
+    });
+    it("places the file in the configured folder", async () => {
+        const dir = await tmpDir("laneyard-logs-");
+        const store = new LogStore(dir);
+        expect(store.pathFor(7)).toBe(join(dir, "7.log"));
+    });
+});

package/dist/tests/main.test.js

@@ -0,0 +1,27 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { createServerFromConfig } from "../src/main.js";
+import { hashPassword } from "../src/server/auth.js";
+import { openDatabase } from "../src/db/open.js";
+import { RunStore } from "../src/db/runs.js";
+import { tmpDir } from "./fixtures/repos.js";
+describe("createServerFromConfig", () => {
+    it("refuses to start if the configuration is invalid", async () => {
+        const root = await tmpDir("laneyard-main-");
+        await writeFile(join(root, "config.yml"), "projects: [", "utf8");
+        await expect(createServerFromConfig(root)).rejects.toThrow(/configuration/i);
+    });
+    it("marks runs still active at startup as interrupted", async () => {
+        const root = await tmpDir("laneyard-main-");
+        await mkdir(root, { recursive: true });
+        await writeFile(join(root, "config.yml"), `server: { password_hash: "${hashPassword("x")}" }\nprojects: []\n`, "utf8");
+        const dbPath = join(root, "laneyard.db");
+        const runs = new RunStore(openDatabase(dbPath));
+        const id = runs.create({ projectSlug: "p", lane: "a", platform: null, params: {} });
+        runs.markRunning(id, { branch: "main", commitSha: "x" });
+        const { app, db } = await createServerFromConfig(root);
+        await app.close();
+        expect(new RunStore(db).get(id)?.status).toBe("interrupted");
+    });
+});

package/dist/tests/ruby/introspect.test.js

@@ -0,0 +1,59 @@
+import { execFile } from "node:child_process";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { describe, expect, it } from "vitest";
+import { resolveRubyEnv } from "../../src/sidecar/ruby-env.js";
+import { tmpDir } from "../fixtures/repos.js";
+const exec = promisify(execFile);
+const SCRIPT = join(process.cwd(), "ruby", "introspect.rb");
+async function projectWithFastfile(content) {
+    const dir = await tmpDir("laneyard-fl-");
+    await mkdir(join(dir, "fastlane"), { recursive: true });
+    await writeFile(join(dir, "fastlane", "Fastfile"), content, "utf8");
+    return dir;
+}
+async function introspect(dir, cmd) {
+    // The sidecar runs here without bundle: it needs the resolved environment.
+    const ruby = await resolveRubyEnv();
+    if (!ruby)
+        throw new Error("fastlane not found for the current Ruby");
+    const { stdout } = await exec("ruby", [SCRIPT, cmd, "--fastlane-dir", "fastlane"], {
+        cwd: dir,
+        env: ruby.env,
+        timeout: 180_000,
+    });
+    return JSON.parse(stdout);
+}
+describe("introspect.rb lanes", () => {
+    it("lists lanes with platform and description", async () => {
+        const dir = await projectWithFastfile(`
+      platform :ios do
+        desc "Push a new beta build to TestFlight"
+        lane :beta do
+          increment_build_number
+        end
+
+        private_lane :helper do
+        end
+      end
+
+      lane :global do
+      end
+    `);
+        const res = (await introspect(dir, "lanes"));
+        expect(res.ok).toBe(true);
+        const beta = res.lanes.find((l) => l.name === "beta");
+        expect(beta).toBeDefined();
+        expect(beta.platform).toBe("ios");
+        expect(beta.description).toBe("Push a new beta build to TestFlight");
+        expect(res.lanes.find((l) => l.name === "global")?.platform).toBeNull();
+        expect(res.lanes.find((l) => l.name === "helper")?.private).toBe(true);
+    }, 180_000);
+    it("returns a structured error on an invalid Fastfile", async () => {
+        const dir = await projectWithFastfile("lane :beta do\n  # never closed\n");
+        const res = (await introspect(dir, "lanes"));
+        expect(res.ok).toBe(false);
+        expect(res.error.length).toBeGreaterThan(0);
+    }, 180_000);
+});

package/dist/tests/runner/artifacts.test.js

@@ -0,0 +1,49 @@
+import { mkdir, readdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { collectArtifacts, guessKind } from "../../src/runner/artifacts.js";
+import { tmpDir } from "../fixtures/repos.js";
+async function workspaceWith(files) {
+    const dir = await tmpDir("laneyard-art-");
+    for (const f of files) {
+        await mkdir(join(dir, f, ".."), { recursive: true });
+        await writeFile(join(dir, f), "content", "utf8");
+    }
+    return dir;
+}
+describe("guessKind", () => {
+    it("recognizes the common types", () => {
+        expect(guessKind("Sample.ipa")).toBe("ipa");
+        expect(guessKind("app-release.aab")).toBe("aab");
+        expect(guessKind("app.apk")).toBe("apk");
+        expect(guessKind("Sample.app.dSYM.zip")).toBe("dsym");
+        expect(guessKind("notes.txt")).toBe("other");
+    });
+});
+describe("collectArtifacts", () => {
+    it("moves files matching the patterns out of the workspace", async () => {
+        const ws = await workspaceWith(["build/Sample.ipa", "build/notes.txt"]);
+        const dest = await tmpDir("laneyard-dest-");
+        const found = await collectArtifacts(ws, ["build/**/*.ipa"], dest);
+        expect(found).toHaveLength(1);
+        expect(found[0].filename).toBe("Sample.ipa");
+        expect(found[0].kind).toBe("ipa");
+        expect(found[0].size).toBeGreaterThan(0);
+        expect(await readdir(dest)).toEqual(["Sample.ipa"]);
+    });
+    it("returns nothing when no pattern is configured", async () => {
+        const ws = await workspaceWith(["build/Sample.ipa"]);
+        expect(await collectArtifacts(ws, [], await tmpDir())).toEqual([]);
+    });
+    it("disambiguates two files with the same name", async () => {
+        const ws = await workspaceWith(["a/app.apk", "b/app.apk"]);
+        const dest = await tmpDir("laneyard-dest-");
+        const found = await collectArtifacts(ws, ["**/*.apk"], dest);
+        expect(found).toHaveLength(2);
+        expect(new Set(found.map((f) => f.filename)).size).toBe(2);
+    });
+    it("ignores a pattern that matches nothing without failing", async () => {
+        const ws = await workspaceWith(["build/Sample.ipa"]);
+        expect(await collectArtifacts(ws, ["does-not-exist/**/*.zip"], await tmpDir())).toEqual([]);
+    });
+});

package/dist/tests/runner/live-steps.test.js

@@ -0,0 +1,35 @@
+import { describe, expect, it } from "vitest";
+import { LiveStepTracker } from "../../src/runner/live-steps.js";
+describe("LiveStepTracker", () => {
+    it("spots a step and keeps its offset", () => {
+        const t = new LiveStepTracker();
+        t.consume("[09:41:02]: noise before\n", 0);
+        t.consume("[09:41:03]: ------ Step: build_app ------\n", 30);
+        expect(t.steps()).toEqual([{ name: "build_app", logOffset: 30 }]);
+    });
+    it("spots several steps in order of appearance", () => {
+        const t = new LiveStepTracker();
+        t.consume("[t]: --- Step: match ---\n[t]: --- Step: build_app ---\n", 100);
+        expect(t.steps().map((s) => s.name)).toEqual(["match", "build_app"]);
+        expect(t.steps()[0].logOffset).toBe(100);
+        expect(t.steps()[1].logOffset).toBeGreaterThan(100);
+    });
+    it("rejoins a line split across two fragments", () => {
+        const t = new LiveStepTracker();
+        t.consume("[t]: ------ Step: buil", 0);
+        t.consume("d_app ------\n", 17);
+        expect(t.steps().map((s) => s.name)).toEqual(["build_app"]);
+    });
+    it("spots a real fastlane separator, ANSI colors included", () => {
+        const t = new LiveStepTracker();
+        // Line copied from a real run: the name of a `sh` action is the
+        // entire command, spaces included.
+        t.consume("[13:14:00]: --- Step: mkdir -p ../build && echo x > y.ipa ---\r\n", 0);
+        expect(t.steps().map((s) => s.name)).toEqual(["mkdir -p ../build && echo x > y.ipa"]);
+    });
+    it("ignores a line that mentions Step without being a separator", () => {
+        const t = new LiveStepTracker();
+        t.consume("The word Step: appears here with no dashes\n", 0);
+        expect(t.steps()).toEqual([]);
+    });
+});

package/dist/tests/runner/orchestrate.test.js

@@ -0,0 +1,124 @@
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { openDatabase } from "../../src/db/open.js";
+import { RunStore } from "../../src/db/runs.js";
+import { LogStore } from "../../src/logs/store.js";
+import { executeRun } from "../../src/runner/orchestrate.js";
+import { makeOriginRepo, tmpDir } from "../fixtures/repos.js";
+const FAKE_DIR = join(process.cwd(), "tests", "fixtures", "fake-fastlane");
+const SETTINGS = {
+    fastlane_dir: "fastlane",
+    runtime: "system",
+    timeout_minutes: 5,
+    interactive_default: false,
+    artifact_globs: ["build/**/*.ipa"],
+    required_secrets: [],
+};
+async function harness(scenario) {
+    const origin = await makeOriginRepo({
+        "fastlane/Fastfile": "lane :beta do\nend\n",
+        // build/ is ignored: the artifact is produced by the fake fastlane during
+        // the run, just like the real one. Nothing tracked by git is moved, so
+        // the workspace stays clean for the next run.
+        ".gitignore": "build/\n",
+    });
+    const root = await tmpDir("laneyard-root-");
+    const db = openDatabase(":memory:");
+    const runs = new RunStore(db);
+    const logs = new LogStore(join(root, "logs"));
+    const runId = runs.create({ projectSlug: "p", lane: "beta", platform: null, params: {} });
+    const result = await executeRun({
+        runId,
+        runs,
+        logs,
+        workspacePath: join(root, "workspaces", "p"),
+        artifactsDir: join(root, "artifacts", String(runId)),
+        gitUrl: origin,
+        branch: "main",
+        resolveSettings: async () => SETTINGS,
+        env: { PATH: `${FAKE_DIR}:${process.env["PATH"]}`, FAKE_FASTLANE_SCENARIO: scenario },
+        onChunk: () => { },
+    });
+    return { runId, runs, logs, result };
+}
+describe("executeRun", () => {
+    it("carries a run through to success end to end", async () => {
+        const { runId, runs, logs } = await harness("success");
+        const run = runs.get(runId);
+        expect(run.status).toBe("success");
+        expect(run.exitCode).toBe(0);
+        expect(run.commitSha).toMatch(/^[0-9a-f]{40}$/);
+        expect(run.startedAt).not.toBeNull();
+        expect(await logs.read(runId)).toContain("Step: build_app");
+    }, 60_000);
+    it("records the report's steps with the live-spotting offset", async () => {
+        const { runId, runs } = await harness("success");
+        const steps = runs.steps(runId);
+        expect(steps.map((s) => s.name)).toEqual(["match", "build_app"]);
+        expect(steps[0].source).toBe("report");
+        expect(steps[0].durationMs).toBe(1500);
+        expect(steps[1].logOffset).toBeGreaterThan(0);
+    }, 60_000);
+    it("collects the artifacts matching the patterns", async () => {
+        const { runId, runs } = await harness("success");
+        const arts = runs.artifacts(runId);
+        expect(arts).toHaveLength(1);
+        expect(arts[0].filename).toBe("Sample.ipa");
+        expect(arts[0].kind).toBe("ipa");
+    }, 60_000);
+    it("marks the failure and keeps an error summary", async () => {
+        const { runId, runs } = await harness("failure");
+        const run = runs.get(runId);
+        expect(run.status).toBe("failed");
+        expect(run.exitCode).toBe(1);
+        expect(runs.steps(runId).find((s) => s.name === "build_app")?.status).toBe("failed");
+    }, 60_000);
+    it("fails cleanly if resolving settings throws", async () => {
+        const origin = await makeOriginRepo({ "fastlane/Fastfile": "lane :beta do\nend\n" });
+        const root = await tmpDir("laneyard-root-");
+        const runs = new RunStore(openDatabase(":memory:"));
+        const logs = new LogStore(join(root, "logs"));
+        const runId = runs.create({ projectSlug: "p", lane: "beta", platform: null, params: {} });
+        await executeRun({
+            runId,
+            runs,
+            logs,
+            workspacePath: join(root, "ws"),
+            artifactsDir: join(root, "art"),
+            gitUrl: origin,
+            branch: "main",
+            // Real case: the project disappeared from config.yml during preparation.
+            resolveSettings: async () => {
+                throw new Error("unknown project");
+            },
+            env: {},
+            onChunk: () => { },
+        });
+        const run = runs.get(runId);
+        expect(run.status).toBe("failed");
+        expect(run.errorSummary).toMatch(/unknown project/);
+    }, 60_000);
+    it("fails before launch if the repository is unreachable", async () => {
+        const root = await tmpDir("laneyard-root-");
+        const runs = new RunStore(openDatabase(":memory:"));
+        const logs = new LogStore(join(root, "logs"));
+        const runId = runs.create({ projectSlug: "p", lane: "beta", platform: null, params: {} });
+        await executeRun({
+            runId,
+            runs,
+            logs,
+            workspacePath: join(root, "ws"),
+            artifactsDir: join(root, "art"),
+            gitUrl: "/nexiste/pas/depot.git",
+            branch: "main",
+            resolveSettings: async () => SETTINGS,
+            env: {},
+            onChunk: () => { },
+        });
+        const run = runs.get(runId);
+        expect(run.status).toBe("failed");
+        expect(run.errorSummary).toMatch(/git|repository|clone/i);
+        // A run that never reached fastlane has no steps.
+        expect(runs.steps(runId)).toEqual([]);
+    }, 60_000);
+});

package/dist/tests/runner/pty.test.js

@@ -0,0 +1,53 @@
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { runInPty } from "../../src/runner/pty.js";
+import { tmpDir } from "../fixtures/repos.js";
+const FAKE_DIR = join(process.cwd(), "tests", "fixtures", "fake-fastlane");
+describe("runInPty", () => {
+    it("streams the output and returns a zero exit code on success", async () => {
+        const chunks = [];
+        const res = await runInPty({
+            command: "fastlane",
+            args: ["beta"],
+            cwd: await tmpDir(),
+            env: { PATH: `${FAKE_DIR}:${process.env["PATH"]}`, FAKE_FASTLANE_SCENARIO: "success" },
+            onData: (c) => chunks.push(c),
+        });
+        expect(res.exitCode).toBe(0);
+        expect(chunks.join("")).toContain("Step: build_app");
+    });
+    it("reports the exit code of a failure", async () => {
+        const res = await runInPty({
+            command: "fastlane",
+            args: ["beta"],
+            cwd: await tmpDir(),
+            env: { PATH: `${FAKE_DIR}:${process.env["PATH"]}`, FAKE_FASTLANE_SCENARIO: "failure" },
+            onData: () => { },
+        });
+        expect(res.exitCode).toBe(1);
+    });
+    it("kills the process past the allotted timeout", async () => {
+        const res = await runInPty({
+            command: "fastlane",
+            args: ["beta"],
+            cwd: await tmpDir(),
+            env: { PATH: `${FAKE_DIR}:${process.env["PATH"]}`, FAKE_FASTLANE_SCENARIO: "slow" },
+            onData: () => { },
+            timeoutMs: 1000,
+        });
+        expect(res.timedOut).toBe(true);
+        // Killed by signal: the code must reflect the violent death, not be 0.
+        expect(res.exitCode).not.toBe(0);
+        expect(res.signal).not.toBeNull();
+    }, 20_000);
+    it("fails cleanly if the command doesn't exist", async () => {
+        const res = await runInPty({
+            command: "nonexistent-command-xyz",
+            args: [],
+            cwd: await tmpDir(),
+            env: { PATH: "/does-not-exist" },
+            onData: () => { },
+        });
+        expect(res.exitCode).not.toBe(0);
+    });
+});

package/dist/tests/runner/report.test.js

@@ -0,0 +1,91 @@
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { readReport } from "../../src/runner/report.js";
+import { tmpDir } from "../fixtures/repos.js";
+// Real form observed: successful actions are self-closing.
+const OK = `<?xml version="1.0" encoding="UTF-8"?>
+<testsuites>
+  <testsuite name="fastlane.lanes">
+    <testcase classname="fastlane.lanes" name="0: match" time="11.5"/>
+    <testcase classname="fastlane.lanes" name="1: build_app" time="238.25"/>
+  </testsuite>
+</testsuites>`;
+// Mixed report: this is the case that traps a badly ordered pattern.
+const FAILED = `<?xml version="1.0" encoding="UTF-8"?>
+<testsuites>
+  <testsuite name="fastlane.lanes">
+    <testcase classname="fastlane.lanes" name="0: match" time="1.0"/>
+    <testcase classname="fastlane.lanes" name="1: build_app" time="12.0">
+      <failure message="Error building the application"></failure>
+    </testcase>
+  </testsuite>
+</testsuites>`;
+describe("readReport", () => {
+    it("extracts name, index, and duration for each action", async () => {
+        const dir = await tmpDir("laneyard-rep-");
+        await writeFile(join(dir, "report.xml"), OK, "utf8");
+        const steps = await readReport(join(dir, "report.xml"));
+        expect(steps).toEqual([
+            { idx: 0, name: "match", durationMs: 11_500, status: "success" },
+            { idx: 1, name: "build_app", durationMs: 238_250, status: "success" },
+        ]);
+    });
+    it("attributes the failure only to the action concerned in a mixed report", async () => {
+        const dir = await tmpDir("laneyard-rep-");
+        await writeFile(join(dir, "report.xml"), FAILED, "utf8");
+        const steps = await readReport(join(dir, "report.xml"));
+        // Narrows the type as much as it verifies: the rest of the test indexes the array.
+        if (!steps)
+            throw new Error("expected report");
+        expect(steps).toHaveLength(2);
+        expect(steps[0].status).toBe("success");
+        expect(steps[1].name).toBe("build_app");
+        expect(steps[1].status).toBe("failed");
+    });
+    it("decodes the XML entities in an action's name", async () => {
+        const dir = await tmpDir("laneyard-rep-");
+        // Real case: a `sh` action's name is the command, escaped by the report.
+        await writeFile(join(dir, "report.xml"), `<testsuites><testsuite name="fastlane.lanes">
+         <testcase classname="fastlane.lanes" name="0: mkdir -p b &amp;&amp; echo x &gt; y" time="0.1"/>
+       </testsuite></testsuites>`, "utf8");
+        const steps = await readReport(join(dir, "report.xml"));
+        expect(steps?.[0]?.name).toBe("mkdir -p b && echo x > y");
+    });
+    it("returns null if the report doesn't exist", async () => {
+        const dir = await tmpDir("laneyard-rep-");
+        expect(await readReport(join(dir, "report.xml"))).toBeNull();
+    });
+    it("returns null on an unreadable report rather than throwing", async () => {
+        const dir = await tmpDir("laneyard-rep-");
+        await writeFile(join(dir, "report.xml"), "<testsuites", "utf8");
+        expect(await readReport(join(dir, "report.xml"))).toBeNull();
+    });
+});
+describe("readReport — unreliable indexes", () => {
+    it("renumbers duplicate indexes rather than letting them into the database", async () => {
+        const dir = await tmpDir("laneyard-rep-");
+        // Two testsuites, each renumbering from 0: run_step's primary key
+        // (run_id, idx) would refuse the insert.
+        await writeFile(join(dir, "report.xml"), `<testsuites>
+         <testsuite name="fastlane.lanes">
+           <testcase classname="fastlane.lanes" name="0: match" time="1"/>
+         </testsuite>
+         <testsuite name="fastlane.lanes">
+           <testcase classname="fastlane.lanes" name="0: build_app" time="2"/>
+           <testcase classname="fastlane.lanes" name="no index" time="3"/>
+         </testsuite>
+       </testsuites>`, "utf8");
+        const steps = await readReport(join(dir, "report.xml"));
+        if (!steps)
+            throw new Error("expected report");
+        expect(steps).toHaveLength(3);
+        expect(steps.map((s) => s.idx)).toEqual([0, 1, 2]);
+        expect(new Set(steps.map((s) => s.idx)).size).toBe(3);
+    });
+    it("lets an out-of-range numeric entity through without throwing", async () => {
+        const dir = await tmpDir("laneyard-rep-");
+        await writeFile(join(dir, "report.xml"), '<testsuites><testsuite name="l"><testcase name="0: &#9999999999;" time="1"/></testsuite></testsuites>', "utf8");
+        await expect(readReport(join(dir, "report.xml"))).resolves.toHaveLength(1);
+    });
+});