factorio-test-cli 2.0.1 → 3.0.1

package/output-formatter.test.js

@@ -0,0 +1,93 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { OutputFormatter } 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");
+    });
+});

package/package.json

@@ -1,32 +1,44 @@
 {
   "name": "factorio-test-cli",
-  "version": "2.0.1",
+  "version": "3.0.1",
   "description": "A CLI to run FactorioTest.",
   "license": "MIT",
-  "repository": "https://github.com/GlassBricks/FactorioTest",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/GlassBricks/FactorioTest.git"
+  },
   "type": "module",
   "bin": {
-    "factorio-test": "./cli.js"
+    "factorio-test": "cli.js"
   },
   "engines": {
     "node": ">=18.0.0"
   },
   "files": [
-    "*.js"
+    "**/*.js",
+    "headless-save.zip"
   ],
   "dependencies": {
-    "chalk": "^5.3.0",
+    "chalk": "^5.6.2",
     "commander": "^12.1.0",
-    "factoriomod-debug": "^2.0.3"
+    "factoriomod-debug": "^2.0.10",
+    "log-update": "^7.0.2",
+    "minimatch": "^10.1.1",
+    "zod": "^3.24.0"
   },
   "devDependencies": {
     "@commander-js/extra-typings": "^12.1.0",
     "del-cli": "^6.0.0",
-    "typescript": "^5.7.2"
+    "typescript": "^5.9.3",
+    "vitest": "^3.0.0"
   },
   "scripts": {
     "build": "npm run clean && tsc",
+    "cli": "tsx cli.ts",
     "lint": "eslint .",
+    "pretest": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "prepublishOnly": "npm run build",
     "clean": "del-cli \"*.js\""
   }

package/process-utils.js

@@ -0,0 +1,27 @@
+import { spawn } from "child_process";
+import { CliError } from "./cli-error.js";
+let verbose = false;
+export function setVerbose(v) {
+    verbose = v;
+}
+export function runScript(...command) {
+    return runProcess(true, "npx", ...command);
+}
+export function runProcess(inheritStdio, command, ...args) {
+    if (verbose)
+        console.log("Running:", command, ...args);
+    const proc = spawn(command, args, {
+        stdio: inheritStdio ? "inherit" : "ignore",
+    });
+    return new Promise((resolve, reject) => {
+        proc.on("error", reject);
+        proc.on("exit", (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new CliError(`Command exited with code ${code}: ${command} ${args.join(" ")}`));
+            }
+        });
+    });
+}

package/progress-renderer.js

@@ -0,0 +1,70 @@
+import chalk from "chalk";
+import logUpdate from "log-update";
+export class ProgressRenderer {
+    isTTY;
+    active = false;
+    total = 0;
+    ran = 0;
+    passed = 0;
+    failed = 0;
+    skipped = 0;
+    todo = 0;
+    currentTest;
+    constructor(isTTY = process.stdout.isTTY ?? false) {
+        this.isTTY = isTTY;
+    }
+    handleEvent(event) {
+        if (event.type === "testRunStarted") {
+            this.total = event.total;
+        }
+        else if (event.type === "testStarted") {
+            this.currentTest = event.test.path;
+            this.render();
+        }
+    }
+    handleTestFinished(test) {
+        this.currentTest = undefined;
+        this.ran++;
+        if (test.result === "passed")
+            this.passed++;
+        else if (test.result === "failed")
+            this.failed++;
+        else if (test.result === "skipped")
+            this.skipped++;
+        else if (test.result === "todo")
+            this.todo++;
+    }
+    withPermanentOutput(callback) {
+        if (!this.isTTY || !this.active) {
+            callback();
+            return;
+        }
+        logUpdate.clear();
+        callback();
+        this.render();
+    }
+    finish() {
+        if (this.active)
+            logUpdate.clear();
+    }
+    render() {
+        if (!this.isTTY)
+            return;
+        this.active = true;
+        const percent = this.total > 0 ? Math.floor((this.ran / this.total) * 100) : 0;
+        const barWidth = 20;
+        const filled = Math.floor((percent / 100) * barWidth);
+        const bar = "█".repeat(filled) + "░".repeat(barWidth - filled);
+        const counts = [
+            chalk.green(`✓${this.passed}`),
+            this.failed > 0 ? chalk.red(`✗${this.failed}`) : null,
+            this.skipped > 0 ? chalk.yellow(`○${this.skipped}`) : null,
+            this.todo > 0 ? chalk.magenta(`◌${this.todo}`) : null,
+        ]
+            .filter(Boolean)
+            .join(" ");
+        const progress = `[${bar}] ${percent}%  ${this.ran}/${this.total}  ${counts}`;
+        const current = this.currentTest ? `Running: ${this.currentTest}` : "";
+        logUpdate(progress + "\n" + current);
+    }
+}

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");
+    });
+});