factorio-test-cli 2.0.1 → 3.0.0

package/progress-renderer.test.js

@@ -0,0 +1,88 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import logUpdate from "log-update";
+import { ProgressRenderer } from "./progress-renderer.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");
+        });
+    });
+    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();
+        });
+    });
+});

package/results-writer.js

@@ -0,0 +1,30 @@
+import * as fsp from "fs/promises";
+import * as path from "path";
+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/results-writer.test.js

@@ -0,0 +1,89 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import * as fsp from "fs/promises";
+import { writeResultsFile, readPreviousFailedTests, getDefaultOutputPath, } from "./results-writer.js";
+vi.mock("fs/promises");
+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");
+    });
+});