factorio-test-cli 3.0.2 → 3.0.3

package/test-output.test.js

@@ -0,0 +1,256 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import logUpdate from "log-update";
+import { ProgressRenderer, OutputFormatter, OutputPrinter } from "./test-output.js";
+vi.mock("log-update", () => ({
+    default: Object.assign(vi.fn(), { clear: vi.fn() }),
+}));
+describe("ProgressRenderer", () => {
+    beforeEach(() => {
+        vi.mocked(logUpdate).mockClear();
+        vi.mocked(logUpdate.clear).mockClear();
+    });
+    describe("withPermanentOutput", () => {
+        it("clears and re-renders around permanent output when active", () => {
+            const renderer = new ProgressRenderer(true);
+            renderer.handleEvent({ type: "testRunStarted", total: 10 });
+            renderer.handleEvent({ type: "testStarted", test: { path: "test" } });
+            vi.mocked(logUpdate).mockClear();
+            vi.mocked(logUpdate.clear).mockClear();
+            let callbackExecuted = false;
+            renderer.withPermanentOutput(() => {
+                callbackExecuted = true;
+            });
+            expect(logUpdate.clear).toHaveBeenCalledTimes(1);
+            expect(callbackExecuted).toBe(true);
+            expect(logUpdate).toHaveBeenCalledTimes(1);
+        });
+        it("executes callback without clear when not active", () => {
+            const renderer = new ProgressRenderer(true);
+            let callbackExecuted = false;
+            renderer.withPermanentOutput(() => {
+                callbackExecuted = true;
+            });
+            expect(callbackExecuted).toBe(true);
+            expect(logUpdate.clear).not.toHaveBeenCalled();
+        });
+        it("executes callback without clear when not TTY", () => {
+            const renderer = new ProgressRenderer(false);
+            let callbackExecuted = false;
+            renderer.withPermanentOutput(() => {
+                callbackExecuted = true;
+            });
+            expect(callbackExecuted).toBe(true);
+            expect(logUpdate.clear).not.toHaveBeenCalled();
+            expect(logUpdate).not.toHaveBeenCalled();
+        });
+    });
+    describe("render", () => {
+        it("renders nothing when not TTY", () => {
+            const renderer = new ProgressRenderer(false);
+            renderer.handleEvent({ type: "testRunStarted", total: 10 });
+            renderer.handleEvent({ type: "testStarted", test: { path: "test" } });
+            expect(logUpdate).not.toHaveBeenCalled();
+        });
+        it("renders progress bar when TTY via withPermanentOutput", () => {
+            const renderer = new ProgressRenderer(true);
+            renderer.handleEvent({ type: "testRunStarted", total: 10 });
+            renderer.handleEvent({ type: "testStarted", test: { path: "test" } });
+            vi.mocked(logUpdate).mockClear();
+            renderer.handleTestFinished({ path: "test", result: "passed", errors: [], logs: [] });
+            renderer.withPermanentOutput(() => { });
+            expect(logUpdate).toHaveBeenCalled();
+            const output = vi.mocked(logUpdate).mock.calls[0][0];
+            expect(output).toContain("10%");
+            expect(output).toContain("1/10");
+        });
+        it("includes current test when running", () => {
+            const renderer = new ProgressRenderer(true);
+            renderer.handleEvent({ type: "testRunStarted", total: 10 });
+            renderer.handleEvent({ type: "testStarted", test: { path: "describe > my test" } });
+            const output = vi.mocked(logUpdate).mock.calls[0][0];
+            expect(output).toContain("Running: describe > my test");
+        });
+        it("handles ran exceeding total without error", () => {
+            const renderer = new ProgressRenderer(true);
+            renderer.handleEvent({ type: "testRunStarted", total: 2 });
+            for (let i = 0; i < 5; i++) {
+                renderer.handleTestFinished({ path: `test${i}`, result: "passed", errors: [], logs: [] });
+            }
+            expect(() => {
+                renderer.handleEvent({ type: "testStarted", test: { path: "extra test" } });
+            }).not.toThrow();
+        });
+        it("does not count skipped or todo tests in ran", () => {
+            const renderer = new ProgressRenderer(true);
+            renderer.handleEvent({ type: "testRunStarted", total: 2 });
+            renderer.handleTestFinished({ path: "test1", result: "passed", errors: [], logs: [] });
+            renderer.handleTestFinished({ path: "skipped", result: "skipped", errors: [], logs: [] });
+            renderer.handleTestFinished({ path: "todo", result: "todo", errors: [], logs: [] });
+            renderer.handleTestFinished({ path: "test2", result: "failed", errors: [], logs: [] });
+            vi.mocked(logUpdate).mockClear();
+            renderer.handleEvent({ type: "testStarted", test: { path: "next" } });
+            const output = vi.mocked(logUpdate).mock.calls[0][0];
+            expect(output).toContain("2/2");
+            expect(output).toContain("100%");
+        });
+    });
+    describe("finish", () => {
+        it("clears on finish when active", () => {
+            const renderer = new ProgressRenderer(true);
+            renderer.handleEvent({ type: "testRunStarted", total: 10 });
+            renderer.handleEvent({ type: "testStarted", test: { path: "test" } });
+            renderer.finish();
+            expect(logUpdate.clear).toHaveBeenCalled();
+        });
+        it("does not clear when not active", () => {
+            const renderer = new ProgressRenderer(true);
+            renderer.finish();
+            expect(logUpdate.clear).not.toHaveBeenCalled();
+        });
+    });
+});
+describe("OutputFormatter", () => {
+    let consoleSpy;
+    let output;
+    beforeEach(() => {
+        output = [];
+        consoleSpy = vi.spyOn(console, "log").mockImplementation((...args) => {
+            output.push(args.join(" "));
+        });
+    });
+    afterEach(() => {
+        consoleSpy.mockRestore();
+    });
+    const passedTest = {
+        path: "root > test1",
+        result: "passed",
+        errors: [],
+        logs: [],
+        durationMs: 1.23,
+    };
+    const failedTest = {
+        path: "root > failing",
+        result: "failed",
+        errors: ["assertion failed", "at test.ts:10"],
+        logs: ["debug output"],
+        durationMs: 0.5,
+    };
+    it("formats passed test with duration", () => {
+        const formatter = new OutputFormatter({});
+        formatter.formatTestResult(passedTest);
+        expect(output).toHaveLength(1);
+        expect(output[0]).toContain("PASS");
+        expect(output[0]).toContain("root > test1");
+        expect(output[0]).toContain("1.2ms");
+    });
+    it("formats failed test with errors", () => {
+        const formatter = new OutputFormatter({});
+        formatter.formatTestResult(failedTest);
+        expect(output.some((line) => line.includes("FAIL"))).toBe(true);
+        expect(output.some((line) => line.includes("assertion failed"))).toBe(true);
+        expect(output.some((line) => line.includes("at test.ts:10"))).toBe(true);
+    });
+    it("shows logs before failed test result", () => {
+        const formatter = new OutputFormatter({});
+        formatter.formatTestResult(failedTest);
+        const logIndex = output.findIndex((line) => line.includes("debug output"));
+        const failIndex = output.findIndex((line) => line.includes("FAIL"));
+        expect(logIndex).toBeLessThan(failIndex);
+    });
+    it("hides logs for passed tests by default", () => {
+        const formatter = new OutputFormatter({});
+        const testWithLogs = { ...passedTest, logs: ["should not appear"] };
+        formatter.formatTestResult(testWithLogs);
+        expect(output.some((line) => line.includes("should not appear"))).toBe(false);
+    });
+    it("shows logs for passed tests when showPassedLogs is true", () => {
+        const formatter = new OutputFormatter({ showPassedLogs: true });
+        const testWithLogs = { ...passedTest, logs: ["visible log"] };
+        formatter.formatTestResult(testWithLogs);
+        expect(output.some((line) => line.includes("visible log"))).toBe(true);
+    });
+    it("suppresses all output when quiet is true", () => {
+        const formatter = new OutputFormatter({ quiet: true });
+        formatter.formatTestResult(passedTest);
+        formatter.formatTestResult(failedTest);
+        expect(output).toHaveLength(0);
+    });
+    it("formats skipped test", () => {
+        const formatter = new OutputFormatter({});
+        const skippedTest = {
+            path: "skipped test",
+            result: "skipped",
+            errors: [],
+            logs: [],
+        };
+        formatter.formatTestResult(skippedTest);
+        expect(output[0]).toContain("SKIP");
+        expect(output[0]).toContain("skipped test");
+    });
+    it("formats todo test", () => {
+        const formatter = new OutputFormatter({});
+        const todoTest = {
+            path: "todo test",
+            result: "todo",
+            errors: [],
+            logs: [],
+        };
+        formatter.formatTestResult(todoTest);
+        expect(output[0]).toContain("TODO");
+        expect(output[0]).toContain("todo test");
+    });
+});
+describe("OutputPrinter", () => {
+    let consoleSpy;
+    let output;
+    beforeEach(() => {
+        output = [];
+        consoleSpy = vi.spyOn(console, "log").mockImplementation((...args) => {
+            output.push(args.join(" "));
+        });
+    });
+    afterEach(() => {
+        consoleSpy.mockRestore();
+    });
+    const skippedTest = { path: "skipped", result: "skipped", errors: [], logs: [] };
+    const todoTest = { path: "todo", result: "todo", errors: [], logs: [] };
+    const passedTest = { path: "passed", result: "passed", errors: [], logs: [] };
+    const failedTest = { path: "failed", result: "failed", errors: ["err"], logs: [] };
+    it("hides skipped tests without verbose", () => {
+        const printer = new OutputPrinter({});
+        printer.printTestResult(skippedTest);
+        expect(output).toHaveLength(0);
+    });
+    it("shows todo tests without verbose", () => {
+        const printer = new OutputPrinter({});
+        printer.printTestResult(todoTest);
+        expect(output.some((line) => line.includes("TODO"))).toBe(true);
+    });
+    it("shows skipped tests with verbose", () => {
+        const printer = new OutputPrinter({ verbose: true });
+        printer.printTestResult(skippedTest);
+        expect(output.some((line) => line.includes("SKIP"))).toBe(true);
+    });
+    it("shows todo tests with verbose", () => {
+        const printer = new OutputPrinter({ verbose: true });
+        printer.printTestResult(todoTest);
+        expect(output.some((line) => line.includes("TODO"))).toBe(true);
+    });
+    it("shows passed, failed, and todo tests without verbose", () => {
+        const printer = new OutputPrinter({});
+        printer.printTestResult(passedTest);
+        printer.printTestResult(failedTest);
+        printer.printTestResult(todoTest);
+        expect(output.some((line) => line.includes("PASS"))).toBe(true);
+        expect(output.some((line) => line.includes("FAIL"))).toBe(true);
+        expect(output.some((line) => line.includes("TODO"))).toBe(true);
+    });
+    it("hides all tests in quiet mode", () => {
+        const printer = new OutputPrinter({ quiet: true });
+        printer.printTestResult(passedTest);
+        printer.printTestResult(failedTest);
+        printer.printTestResult(skippedTest);
+        printer.printTestResult(todoTest);
+        expect(output).toHaveLength(0);
+    });
+});

package/{test-run-collector.js → test-results.js}

@@ -1,4 +1,6 @@
 import { EventEmitter } from "events";
+import * as fsp from "fs/promises";
+import * as path from "path";
 export class TestRunCollector extends EventEmitter {
     data = { tests: [] };
     currentTest;
@@ -90,3 +92,31 @@ export class TestRunCollector extends EventEmitter {
         this.emit("testFinished", test);
     }
 }
+export async function writeResultsFile(outputPath, modName, data) {
+    const content = {
+        timestamp: new Date().toISOString(),
+        modName,
+        summary: data.summary,
+        tests: data.tests.map((t) => ({
+            path: t.path,
+            result: t.result,
+            ...(t.durationMs !== undefined && { durationMs: t.durationMs }),
+            ...(t.errors.length > 0 && { errors: t.errors }),
+        })),
+    };
+    await fsp.mkdir(path.dirname(outputPath), { recursive: true });
+    await fsp.writeFile(outputPath, JSON.stringify(content, null, 2));
+}
+export async function readPreviousFailedTests(outputPath) {
+    try {
+        const content = await fsp.readFile(outputPath, "utf-8");
+        const parsed = JSON.parse(content);
+        return parsed.tests.filter((t) => t.result === "failed").map((t) => t.path);
+    }
+    catch {
+        return [];
+    }
+}
+export function getDefaultOutputPath(dataDir) {
+    return path.join(dataDir, "test-results.json");
+}

package/{test-run-collector.test.js → test-results.test.js}

@@ -1,5 +1,7 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { TestRunCollector } from "./test-run-collector.js";
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import * as fsp from "fs/promises";
+import { TestRunCollector, writeResultsFile, readPreviousFailedTests, getDefaultOutputPath, } from "./test-results.js";
+vi.mock("fs/promises");
 describe("TestRunCollector", () => {
     let collector;
     beforeEach(() => {
@@ -99,3 +101,88 @@ describe("TestRunCollector", () => {
         expect(data.tests[0].source).toEqual({ file: "test.ts", line: 42 });
     });
 });
+describe("writeResultsFile", () => {
+    beforeEach(() => {
+        vi.mocked(fsp.mkdir).mockResolvedValue(undefined);
+        vi.mocked(fsp.writeFile).mockResolvedValue();
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it("writes results with correct structure", async () => {
+        const data = {
+            tests: [
+                { path: "test1", result: "passed", errors: [], logs: [], durationMs: 1 },
+                { path: "test2", result: "failed", errors: ["error"], logs: [], durationMs: 2 },
+            ],
+            summary: {
+                ran: 2,
+                passed: 1,
+                failed: 1,
+                skipped: 0,
+                todo: 0,
+                cancelled: 0,
+                describeBlockErrors: 0,
+                status: "failed",
+            },
+        };
+        await writeResultsFile("/out/results.json", "test-mod", data);
+        expect(fsp.mkdir).toHaveBeenCalledWith("/out", { recursive: true });
+        const written = JSON.parse(vi.mocked(fsp.writeFile).mock.calls[0][1]);
+        expect(written.modName).toBe("test-mod");
+        expect(written.tests).toHaveLength(2);
+        expect(written.tests[0].errors).toBeUndefined();
+        expect(written.tests[1].errors).toEqual(["error"]);
+    });
+    it("omits duration when not present", async () => {
+        const data = {
+            tests: [{ path: "test1", result: "skipped", errors: [], logs: [] }],
+        };
+        await writeResultsFile("/out/results.json", "test-mod", data);
+        const written = JSON.parse(vi.mocked(fsp.writeFile).mock.calls[0][1]);
+        expect(written.tests[0].durationMs).toBeUndefined();
+    });
+    it("omits errors array when empty", async () => {
+        const data = {
+            tests: [{ path: "test1", result: "passed", errors: [], logs: [], durationMs: 5 }],
+        };
+        await writeResultsFile("/out/results.json", "test-mod", data);
+        const written = JSON.parse(vi.mocked(fsp.writeFile).mock.calls[0][1]);
+        expect(written.tests[0].errors).toBeUndefined();
+    });
+});
+describe("readPreviousFailedTests", () => {
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it("returns failed test paths", async () => {
+        const content = {
+            timestamp: "2026-01-24T00:00:00Z",
+            modName: "test",
+            summary: undefined,
+            tests: [
+                { path: "passing", result: "passed" },
+                { path: "failing1", result: "failed" },
+                { path: "failing2", result: "failed" },
+            ],
+        };
+        vi.mocked(fsp.readFile).mockResolvedValue(JSON.stringify(content));
+        const result = await readPreviousFailedTests("/path/to/results.json");
+        expect(result).toEqual(["failing1", "failing2"]);
+    });
+    it("returns empty array on file not found", async () => {
+        vi.mocked(fsp.readFile).mockRejectedValue(new Error("ENOENT"));
+        const result = await readPreviousFailedTests("/path/to/results.json");
+        expect(result).toEqual([]);
+    });
+    it("returns empty array on invalid JSON", async () => {
+        vi.mocked(fsp.readFile).mockResolvedValue("not valid json");
+        const result = await readPreviousFailedTests("/path/to/results.json");
+        expect(result).toEqual([]);
+    });
+});
+describe("getDefaultOutputPath", () => {
+    it("returns path in data directory", () => {
+        expect(getDefaultOutputPath("/data/dir")).toBe("/data/dir/test-results.json");
+    });
+});

package/buffer-line-splitter.js

@@ -1,31 +0,0 @@
-import { EventEmitter } from "events";
-export default class BufferLineSplitter extends EventEmitter {
-    buf;
-    constructor(instream) {
-        super();
-        this.buf = "";
-        instream.on("close", () => {
-            if (this.buf.length > 0)
-                this.emit("line", this.buf);
-            this.emit("close");
-        });
-        instream.on("end", () => {
-            if (this.buf.length > 0)
-                this.emit("line", this.buf);
-            this.emit("end");
-        });
-        instream.on("data", (chunk) => {
-            this.buf += chunk.toString();
-            while (this.buf.length > 0) {
-                const index = this.buf.search(/\r?\n/);
-                if (index === -1)
-                    break;
-                this.emit("line", this.buf.slice(0, index));
-                this.buf = this.buf.slice(index + 1);
-            }
-        });
-    }
-    on(event, listener) {
-        return super.on(event, listener);
-    }
-}

package/factorio-discovery.js

@@ -1,53 +0,0 @@
-import * as os from "os";
-import * as fs from "fs";
-import * as path from "path";
-import { spawnSync } from "child_process";
-import { CliError } from "./cli-error.js";
-export function getFactorioPlayerDataPath() {
-    const platform = os.platform();
-    if (platform === "win32") {
-        return path.join(process.env.APPDATA, "Factorio", "player-data.json");
-    }
-    if (platform === "darwin") {
-        return path.join(os.homedir(), "Library", "Application Support", "factorio", "player-data.json");
-    }
-    return path.join(os.homedir(), ".factorio", "player-data.json");
-}
-function factorioIsInPath() {
-    const result = spawnSync("factorio", ["--version"], { stdio: "ignore" });
-    return result.status === 0;
-}
-export function autoDetectFactorioPath() {
-    if (factorioIsInPath()) {
-        return "factorio";
-    }
-    let pathsToTry;
-    if (os.platform() === "linux" || os.platform() === "darwin") {
-        pathsToTry = [
-            "~/.local/share/Steam/steamapps/common/Factorio/bin/x64/factorio",
-            "~/Library/Application Support/Steam/steamapps/common/Factorio/factorio.app/Contents/MacOS/factorio",
-            "~/.factorio/bin/x64/factorio",
-            "/Applications/factorio.app/Contents/MacOS/factorio",
-            "/usr/share/factorio/bin/x64/factorio",
-            "/usr/share/games/factorio/bin/x64/factorio",
-        ];
-    }
-    else if (os.platform() === "win32") {
-        pathsToTry = [
-            "factorio.exe",
-            process.env["ProgramFiles(x86)"] + "\\Steam\\steamapps\\common\\Factorio\\bin\\x64\\factorio.exe",
-            process.env["ProgramFiles"] + "\\Factorio\\bin\\x64\\factorio.exe",
-        ];
-    }
-    else {
-        throw new CliError(`Cannot auto-detect factorio path on platform ${os.platform()}`);
-    }
-    pathsToTry = pathsToTry.map((p) => p.replace(/^~\//, os.homedir() + "/"));
-    for (const testPath of pathsToTry) {
-        if (fs.statSync(testPath, { throwIfNoEntry: false })?.isFile()) {
-            return path.resolve(testPath);
-        }
-    }
-    throw new CliError(`Could not auto-detect factorio executable. Tried: ${pathsToTry.join(", ")}. ` +
-        "Either add the factorio bin to your path, or specify the path with --factorio-path");
-}

package/factorio-discovery.test.js

@@ -1,24 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-vi.mock("child_process", () => ({
-    spawnSync: vi.fn(() => ({ status: 1 })),
-}));
-describe("autoDetectFactorioPath", () => {
-    beforeEach(() => {
-        vi.resetModules();
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    it("returns 'factorio' if in PATH", async () => {
-        const { spawnSync } = await import("child_process");
-        vi.mocked(spawnSync).mockReturnValue({ status: 0 });
-        const { autoDetectFactorioPath } = await import("./factorio-discovery.js");
-        expect(autoDetectFactorioPath()).toBe("factorio");
-    });
-    it("throws if no path found and factorio not in PATH", async () => {
-        const { spawnSync } = await import("child_process");
-        vi.mocked(spawnSync).mockReturnValue({ status: 1 });
-        const { autoDetectFactorioPath } = await import("./factorio-discovery.js");
-        expect(() => autoDetectFactorioPath()).toThrow(/Could not auto-detect/);
-    });
-});

package/output-formatter.test.js

@@ -1,137 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { OutputFormatter, OutputPrinter } from "./output-formatter.js";
-describe("OutputFormatter", () => {
-    let consoleSpy;
-    let output;
-    beforeEach(() => {
-        output = [];
-        consoleSpy = vi.spyOn(console, "log").mockImplementation((...args) => {
-            output.push(args.join(" "));
-        });
-    });
-    afterEach(() => {
-        consoleSpy.mockRestore();
-    });
-    const passedTest = {
-        path: "root > test1",
-        result: "passed",
-        errors: [],
-        logs: [],
-        durationMs: 1.23,
-    };
-    const failedTest = {
-        path: "root > failing",
-        result: "failed",
-        errors: ["assertion failed", "at test.ts:10"],
-        logs: ["debug output"],
-        durationMs: 0.5,
-    };
-    it("formats passed test with duration", () => {
-        const formatter = new OutputFormatter({});
-        formatter.formatTestResult(passedTest);
-        expect(output).toHaveLength(1);
-        expect(output[0]).toContain("PASS");
-        expect(output[0]).toContain("root > test1");
-        expect(output[0]).toContain("1.2ms");
-    });
-    it("formats failed test with errors", () => {
-        const formatter = new OutputFormatter({});
-        formatter.formatTestResult(failedTest);
-        expect(output.some((line) => line.includes("FAIL"))).toBe(true);
-        expect(output.some((line) => line.includes("assertion failed"))).toBe(true);
-        expect(output.some((line) => line.includes("at test.ts:10"))).toBe(true);
-    });
-    it("shows logs before failed test result", () => {
-        const formatter = new OutputFormatter({});
-        formatter.formatTestResult(failedTest);
-        const logIndex = output.findIndex((line) => line.includes("debug output"));
-        const failIndex = output.findIndex((line) => line.includes("FAIL"));
-        expect(logIndex).toBeLessThan(failIndex);
-    });
-    it("hides logs for passed tests by default", () => {
-        const formatter = new OutputFormatter({});
-        const testWithLogs = { ...passedTest, logs: ["should not appear"] };
-        formatter.formatTestResult(testWithLogs);
-        expect(output.some((line) => line.includes("should not appear"))).toBe(false);
-    });
-    it("shows logs for passed tests when showPassedLogs is true", () => {
-        const formatter = new OutputFormatter({ showPassedLogs: true });
-        const testWithLogs = { ...passedTest, logs: ["visible log"] };
-        formatter.formatTestResult(testWithLogs);
-        expect(output.some((line) => line.includes("visible log"))).toBe(true);
-    });
-    it("suppresses all output when quiet is true", () => {
-        const formatter = new OutputFormatter({ quiet: true });
-        formatter.formatTestResult(passedTest);
-        formatter.formatTestResult(failedTest);
-        expect(output).toHaveLength(0);
-    });
-    it("formats skipped test", () => {
-        const formatter = new OutputFormatter({});
-        const skippedTest = {
-            path: "skipped test",
-            result: "skipped",
-            errors: [],
-            logs: [],
-        };
-        formatter.formatTestResult(skippedTest);
-        expect(output[0]).toContain("SKIP");
-        expect(output[0]).toContain("skipped test");
-    });
-    it("formats todo test", () => {
-        const formatter = new OutputFormatter({});
-        const todoTest = {
-            path: "todo test",
-            result: "todo",
-            errors: [],
-            logs: [],
-        };
-        formatter.formatTestResult(todoTest);
-        expect(output[0]).toContain("TODO");
-        expect(output[0]).toContain("todo test");
-    });
-});
-describe("OutputPrinter", () => {
-    let consoleSpy;
-    let output;
-    beforeEach(() => {
-        output = [];
-        consoleSpy = vi.spyOn(console, "log").mockImplementation((...args) => {
-            output.push(args.join(" "));
-        });
-    });
-    afterEach(() => {
-        consoleSpy.mockRestore();
-    });
-    const skippedTest = { path: "skipped", result: "skipped", errors: [], logs: [] };
-    const todoTest = { path: "todo", result: "todo", errors: [], logs: [] };
-    const passedTest = { path: "passed", result: "passed", errors: [], logs: [] };
-    const failedTest = { path: "failed", result: "failed", errors: ["err"], logs: [] };
-    it("hides skipped tests without verbose", () => {
-        const printer = new OutputPrinter({});
-        printer.printTestResult(skippedTest);
-        expect(output).toHaveLength(0);
-    });
-    it("hides todo tests without verbose", () => {
-        const printer = new OutputPrinter({});
-        printer.printTestResult(todoTest);
-        expect(output).toHaveLength(0);
-    });
-    it("shows skipped tests with verbose", () => {
-        const printer = new OutputPrinter({ verbose: true });
-        printer.printTestResult(skippedTest);
-        expect(output.some((line) => line.includes("SKIP"))).toBe(true);
-    });
-    it("shows todo tests with verbose", () => {
-        const printer = new OutputPrinter({ verbose: true });
-        printer.printTestResult(todoTest);
-        expect(output.some((line) => line.includes("TODO"))).toBe(true);
-    });
-    it("shows passed and failed tests without verbose", () => {
-        const printer = new OutputPrinter({});
-        printer.printTestResult(passedTest);
-        printer.printTestResult(failedTest);
-        expect(output.some((line) => line.includes("PASS"))).toBe(true);
-        expect(output.some((line) => line.includes("FAIL"))).toBe(true);
-    });
-});