factorio-test-cli 3.0.2 → 3.0.3

package/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { program } from "commander";
 import chalk from "chalk";
+import { program } from "commander";
 import { CliError } from "./cli-error.js";
 import "./run.js";
 try {

package/factorio-output-parser.js

@@ -13,9 +13,14 @@ export function parseEvent(line) {
 }
 export class FactorioOutputHandler extends EventEmitter {
     inMessage = false;
+    resultMessage;
+    getResultMessage() {
+        return this.resultMessage;
+    }
     handleLine(line) {
         if (line.startsWith("FACTORIO-TEST-RESULT:")) {
-            this.emit("result", line.slice("FACTORIO-TEST-RESULT:".length));
+            this.resultMessage = line.slice("FACTORIO-TEST-RESULT:".length);
+            this.emit("result", this.resultMessage);
             return;
         }
         if (line === "FACTORIO-TEST-MESSAGE-START") {

package/factorio-output-parser.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { parseEvent } from "./factorio-output-parser.js";
+import { FactorioOutputHandler, parseEvent } from "./factorio-output-parser.js";
 describe("parseEvent", () => {
     it("parses valid testStarted event", () => {
         const line = 'FACTORIO-TEST-EVENT:{"type":"testStarted","test":{"path":"root > mytest"}}';
@@ -36,3 +36,22 @@ describe("parseEvent", () => {
         expect(parseEvent("FACTORIO-TEST-EVENT:")).toBeUndefined();
     });
 });
+describe("FactorioOutputHandler", () => {
+    it("getResultMessage returns undefined before result received", () => {
+        const handler = new FactorioOutputHandler();
+        expect(handler.getResultMessage()).toBeUndefined();
+    });
+    it("getResultMessage returns result after receiving FACTORIO-TEST-RESULT", () => {
+        const handler = new FactorioOutputHandler();
+        handler.handleLine("FACTORIO-TEST-RESULT:passed");
+        expect(handler.getResultMessage()).toBe("passed");
+    });
+    it("emits result event with message", () => {
+        const handler = new FactorioOutputHandler();
+        const results = [];
+        handler.on("result", (msg) => results.push(msg));
+        handler.handleLine("FACTORIO-TEST-RESULT:failed:focused");
+        expect(results).toEqual(["failed:focused"]);
+        expect(handler.getResultMessage()).toBe("failed:focused");
+    });
+});

package/factorio-process.js

@@ -1,13 +1,84 @@
-import { spawn } from "child_process";
+import { EventEmitter } from "events";
+import { spawn, spawnSync } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
 import * as path from "path";
 import { fileURLToPath } from "url";
-import BufferLineSplitter from "./buffer-line-splitter.js";
 import { FactorioOutputHandler } from "./factorio-output-parser.js";
-import { OutputPrinter } from "./output-formatter.js";
-import { ProgressRenderer } from "./progress-renderer.js";
-import { TestRunCollector } from "./test-run-collector.js";
+import { OutputPrinter, ProgressRenderer } from "./test-output.js";
+import { TestRunCollector } from "./test-results.js";
 import { CliError } from "./cli-error.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
+class BufferLineSplitter extends EventEmitter {
+    buf = "";
+    constructor(stream) {
+        super();
+        stream.on("close", () => {
+            if (this.buf.length > 0)
+                this.emit("line", this.buf);
+        });
+        stream.on("end", () => {
+            if (this.buf.length > 0)
+                this.emit("line", this.buf);
+        });
+        stream.on("data", (chunk) => {
+            this.buf += chunk.toString();
+            let index;
+            while ((index = this.buf.search(/\r?\n/)) !== -1) {
+                this.emit("line", this.buf.slice(0, index));
+                this.buf = this.buf.slice(index + 1);
+            }
+        });
+    }
+}
+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");
+}
 export function getHeadlessSavePath(overridePath) {
     if (overridePath) {
         return path.resolve(overridePath);
@@ -29,11 +100,12 @@ export function parseResultMessage(message) {
 function createOutputComponents(options) {
     const handler = new FactorioOutputHandler();
     const collector = new TestRunCollector();
+    const isTTY = process.stdout.isTTY ?? false;
     const printer = new OutputPrinter({
         verbose: options.verbose,
         quiet: options.quiet,
     });
-    const progress = new ProgressRenderer();
+    const progress = new ProgressRenderer(isTTY);
     handler.on("event", (event) => {
         collector.handleEvent(event);
         progress.handleEvent(event);
@@ -52,7 +124,11 @@ function createOutputComponents(options) {
         progress.handleTestFinished(test);
         progress.withPermanentOutput(() => printer.printTestResult(test));
     });
-    return { handler, collector, printer, progress };
+    handler.on("result", () => {
+        progress.finish();
+        printer.resetMessage();
+    });
+    return { handler, collector };
 }
 export async function runFactorioTestsHeadless(factorioPath, dataDir, savePath, additionalArgs, options) {
     const args = [
@@ -70,16 +146,10 @@ export async function runFactorioTestsHeadless(factorioPath, dataDir, savePath,
     const factorioProcess = spawn(factorioPath, args, {
         stdio: ["inherit", "pipe", "pipe"],
     });
-    const { handler, collector, printer, progress } = createOutputComponents(options);
-    let resultMessage;
+    const { handler, collector } = createOutputComponents(options);
     let testRunStarted = false;
     let startupTimedOut = false;
     let wasCancelled = false;
-    handler.on("result", (msg) => {
-        resultMessage = msg;
-        progress.finish();
-        printer.resetMessage();
-    });
     handler.on("event", (event) => {
         if (event.type === "testRunStarted") {
             testRunStarted = true;
@@ -109,7 +179,7 @@ export async function runFactorioTestsHeadless(factorioPath, dataDir, savePath,
             else if (startupTimedOut) {
                 reject(new CliError("Factorio unresponsive: no test run started within 10 seconds"));
             }
-            else if (resultMessage !== undefined) {
+            else if (handler.getResultMessage() !== undefined) {
                 resolve();
             }
             else {
@@ -120,6 +190,7 @@ export async function runFactorioTestsHeadless(factorioPath, dataDir, savePath,
     if (wasCancelled) {
         return { status: "cancelled", hasFocusedTests: false };
     }
+    const resultMessage = handler.getResultMessage();
     const parsed = parseResultMessage(resultMessage);
     return { ...parsed, message: resultMessage, data: collector.getData() };
 }
@@ -137,22 +208,16 @@ export async function runFactorioTestsGraphics(factorioPath, dataDir, savePath,
     const factorioProcess = spawn(factorioPath, args, {
         stdio: ["inherit", "pipe", "inherit"],
     });
-    const { handler, collector, printer, progress } = createOutputComponents(options);
-    let resultMessage;
+    const { handler, collector } = createOutputComponents(options);
     let resolvePromise;
-    handler.on("result", (msg) => {
-        resultMessage = msg;
-        progress.finish();
-        printer.resetMessage();
-        if (options.resolveOnResult && resolvePromise) {
-            resolvePromise();
-        }
-    });
+    if (options.resolveOnResult) {
+        handler.on("result", () => resolvePromise?.());
+    }
     new BufferLineSplitter(factorioProcess.stdout).on("line", (line) => handler.handleLine(line));
     await new Promise((resolve, reject) => {
         resolvePromise = resolve;
         factorioProcess.on("exit", (code, signal) => {
-            if (resultMessage !== undefined) {
+            if (handler.getResultMessage() !== undefined) {
                 resolve();
             }
             else {
@@ -160,6 +225,7 @@ export async function runFactorioTestsGraphics(factorioPath, dataDir, savePath,
             }
         });
     });
+    const resultMessage = handler.getResultMessage();
     const parsed = parseResultMessage(resultMessage);
     return { ...parsed, message: resultMessage, data: collector.getData() };
 }

package/factorio-process.test.js

@@ -1,5 +1,12 @@
-import { describe, it, expect } from "vitest";
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import { parseResultMessage } from "./factorio-process.js";
+vi.mock("child_process", async (importOriginal) => {
+    const original = await importOriginal();
+    return {
+        ...original,
+        spawnSync: vi.fn(() => ({ status: 1 })),
+    };
+});
 describe("parseResultMessage", () => {
     it.each([
         ["passed", { status: "passed", hasFocusedTests: false }],
@@ -13,3 +20,23 @@ describe("parseResultMessage", () => {
         expect(parseResultMessage(input)).toEqual(expected);
     });
 });
+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-process.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-process.js");
+        expect(() => autoDetectFactorioPath()).toThrow(/Could not auto-detect/);
+    });
+});

package/mod-setup.js

@@ -2,7 +2,7 @@ import * as fsp from "fs/promises";
 import * as fs from "fs";
 import * as path from "path";
 import { runScript, runProcess } from "./process-utils.js";
-import { getFactorioPlayerDataPath } from "./factorio-discovery.js";
+import { getFactorioPlayerDataPath } from "./factorio-process.js";
 import { CliError } from "./cli-error.js";
 const MIN_FACTORIO_TEST_VERSION = "3.0.0";
 function parseVersion(version) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "factorio-test-cli",
-  "version": "3.0.2",
+  "version": "3.0.3",
   "description": "A CLI to run FactorioTest.",
   "license": "MIT",
   "repository": {

package/run.js

@@ -1,16 +1,16 @@
+import chalk from "chalk";
 import { program } from "commander";
+import * as dgram from "dgram";
 import * as fsp from "fs/promises";
 import * as path from "path";
-import * as dgram from "dgram";
-import chalk from "chalk";
-import { loadConfig, mergeCliConfig, buildTestConfig, registerAllCliOptions, } from "./config/index.js";
-import { setVerbose, runScript } from "./process-utils.js";
-import { autoDetectFactorioPath } from "./factorio-discovery.js";
 import { CliError } from "./cli-error.js";
-import { configureModToTest, installFactorioTest, installModDependencies, ensureConfigIni, setSettingsForAutorun, resetAutorunSettings, resolveModWatchTarget, } from "./mod-setup.js";
-import { writeResultsFile, readPreviousFailedTests, getDefaultOutputPath } from "./results-writer.js";
-import { getHeadlessSavePath, runFactorioTestsHeadless, runFactorioTestsGraphics, } from "./factorio-process.js";
+import { buildTestConfig, loadConfig, mergeCliConfig, registerAllCliOptions, } from "./config/index.js";
+import { autoDetectFactorioPath } from "./factorio-process.js";
+import { getHeadlessSavePath, runFactorioTestsGraphics, runFactorioTestsHeadless, } from "./factorio-process.js";
 import { watchDirectory, watchFile } from "./file-watcher.js";
+import { configureModToTest, ensureConfigIni, installFactorioTest, installModDependencies, resetAutorunSettings, resolveModWatchTarget, setSettingsForAutorun, } from "./mod-setup.js";
+import { runScript, setVerbose } from "./process-utils.js";
+import { getDefaultOutputPath, readPreviousFailedTests, writeResultsFile } from "./test-results.js";
 const thisCommand = program
     .command("run")
     .summary("Runs tests with Factorio test.")
@@ -146,68 +146,70 @@ async function executeTestRun(ctx, execOptions) {
     return { exitCode: resultStatus === "passed" ? 0 : 1, status: resultStatus };
 }
 const DEFAULT_WATCH_PATTERNS = ["info.json", "**/*.lua"];
+async function runGraphicsWatchMode(ctx) {
+    const watchPatterns = ctx.options.watchPatterns ?? ctx.fileConfig.watchPatterns ?? DEFAULT_WATCH_PATTERNS;
+    const target = await resolveModWatchTarget(ctx.modsDir, ctx.options.modPath, ctx.options.modName);
+    console.log(chalk.gray(`Watching ${target.path} for patterns: ${watchPatterns.join(", ")}`));
+    await executeTestRun(ctx, { skipResetAutorun: true, resolveOnResult: true });
+    const udpClient = dgram.createSocket("udp4");
+    const onFileChange = () => {
+        console.log(chalk.cyan("File change detected, triggering rerun..."));
+        udpClient.send("rerun", ctx.udpPort, "127.0.0.1");
+    };
+    const watcher = target.type === "directory"
+        ? watchDirectory(target.path, onFileChange, { patterns: watchPatterns })
+        : watchFile(target.path, onFileChange);
+    process.on("SIGINT", () => {
+        watcher.close();
+        udpClient.close();
+        process.exit(0);
+    });
+    return new Promise(() => { });
+}
+async function runHeadlessWatchMode(ctx) {
+    const watchPatterns = ctx.options.watchPatterns ?? ctx.fileConfig.watchPatterns ?? DEFAULT_WATCH_PATTERNS;
+    const target = await resolveModWatchTarget(ctx.modsDir, ctx.options.modPath, ctx.options.modName);
+    let abortController;
+    const runOnce = async () => {
+        abortController?.abort();
+        abortController = new AbortController();
+        console.log("\n" + "─".repeat(60));
+        try {
+            await executeTestRun(ctx, { signal: abortController.signal });
+        }
+        catch (e) {
+            if (e instanceof CliError) {
+                console.error(chalk.red(e.message));
+            }
+            else {
+                throw e;
+            }
+        }
+        finally {
+            abortController = undefined;
+        }
+    };
+    await runOnce();
+    const onFileChange = () => {
+        console.log(chalk.cyan("File change detected, rerunning tests..."));
+        runOnce();
+    };
+    const watcher = target.type === "directory"
+        ? watchDirectory(target.path, onFileChange, { patterns: watchPatterns })
+        : watchFile(target.path, onFileChange);
+    process.on("SIGINT", () => {
+        watcher.close();
+        process.exit(0);
+    });
+    return new Promise(() => { });
+}
 async function runTests(patterns, options) {
     const ctx = await setupTestRun(patterns, options);
     if (options.watch && options.graphics) {
-        const watchPatterns = options.watchPatterns ?? ctx.fileConfig.watchPatterns ?? DEFAULT_WATCH_PATTERNS;
-        const target = await resolveModWatchTarget(ctx.modsDir, options.modPath, options.modName);
-        console.log(chalk.gray(`Watching ${target.path} for patterns: ${watchPatterns.join(", ")}`));
-        await executeTestRun(ctx, { skipResetAutorun: true, resolveOnResult: true });
-        const udpClient = dgram.createSocket("udp4");
-        const onFileChange = () => {
-            console.log(chalk.cyan("File change detected, triggering rerun..."));
-            udpClient.send("rerun", ctx.udpPort, "127.0.0.1");
-        };
-        const watcher = target.type === "directory"
-            ? watchDirectory(target.path, onFileChange, { patterns: watchPatterns })
-            : watchFile(target.path, onFileChange);
-        process.on("SIGINT", () => {
-            watcher.close();
-            udpClient.close();
-            process.exit(0);
-        });
-        await new Promise(() => { });
+        await runGraphicsWatchMode(ctx);
     }
     else if (options.watch) {
-        const watchPatterns = options.watchPatterns ?? ctx.fileConfig.watchPatterns ?? DEFAULT_WATCH_PATTERNS;
-        const target = await resolveModWatchTarget(ctx.modsDir, options.modPath, options.modName);
-        let abortController;
-        let isRunning = false;
-        const runOnce = async () => {
-            if (isRunning) {
-                abortController?.abort();
-            }
-            abortController = new AbortController();
-            isRunning = true;
-            console.log("\n" + "─".repeat(60));
-            try {
-                await executeTestRun(ctx, { signal: abortController.signal });
-            }
-            catch (e) {
-                if (e instanceof CliError) {
-                    console.error(chalk.red(e.message));
-                }
-                else {
-                    throw e;
-                }
-            }
-            finally {
-                isRunning = false;
-            }
-        };
-        await runOnce();
-        const onFileChange = () => {
-            console.log(chalk.cyan("File change detected, rerunning tests..."));
-            runOnce();
-        };
-        const watcher = target.type === "directory"
-            ? watchDirectory(target.path, onFileChange, { patterns: watchPatterns })
-            : watchFile(target.path, onFileChange);
-        process.on("SIGINT", () => {
-            watcher.close();
-            process.exit(0);
-        });
-        await new Promise(() => { });
+        await runHeadlessWatchMode(ctx);
     }
     else {
         const result = await executeTestRun(ctx);

package/{output-formatter.js → test-output.js}

@@ -1,4 +1,78 @@
 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;
+        if (test.result === "passed") {
+            this.ran++;
+            this.passed++;
+        }
+        else if (test.result === "failed") {
+            this.ran++;
+            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.min(barWidth, 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);
+    }
+}
 function formatDuration(ms) {
     if (ms >= 1000) {
         return `${(ms / 1000).toFixed(2)}s`;
@@ -61,19 +135,12 @@ export class OutputPrinter {
         });
     }
     printTestResult(test) {
-        if (this.options.quiet || this.options.useProgressBar)
+        if (this.options.quiet)
             return;
-        if ((test.result === "skipped" || test.result === "todo") && !this.options.verbose)
+        if (test.result === "skipped" && !this.options.verbose)
             return;
         this.formatter.formatTestResult(test);
     }
-    printFailures(tests) {
-        for (const test of tests) {
-            if (test.result === "failed") {
-                this.formatter.formatTestResult(test);
-            }
-        }
-    }
     printMessage(line) {
         if (this.options.quiet)
             return;