factorio-test-cli 2.0.0 → 3.0.0

package/mod-setup.js

@@ -0,0 +1,246 @@
+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 { CliError } from "./cli-error.js";
+const MIN_FACTORIO_TEST_VERSION = "3.0.0";
+function parseVersion(version) {
+    const parts = version.split(".").map(Number);
+    return [parts[0] ?? 0, parts[1] ?? 0, parts[2] ?? 0];
+}
+function compareVersions(a, b) {
+    const [aMajor, aMinor, aPatch] = parseVersion(a);
+    const [bMajor, bMinor, bPatch] = parseVersion(b);
+    if (aMajor !== bMajor)
+        return aMajor - bMajor;
+    if (aMinor !== bMinor)
+        return aMinor - bMinor;
+    return aPatch - bPatch;
+}
+export async function configureModToTest(modsDir, modPath, modName, verbose) {
+    if (modPath) {
+        if (verbose)
+            console.log("Creating mod symlink", modPath);
+        return configureModPath(modPath, modsDir);
+    }
+    else {
+        await configureModName(modsDir, modName);
+        return modName;
+    }
+}
+async function configureModPath(modPath, modsDir) {
+    modPath = path.resolve(modPath);
+    const infoJsonFile = path.join(modPath, "info.json");
+    let infoJson;
+    try {
+        infoJson = JSON.parse(await fsp.readFile(infoJsonFile, "utf8"));
+    }
+    catch (e) {
+        throw new CliError(`Could not read info.json file from ${modPath}`, { cause: e });
+    }
+    const modName = infoJson.name;
+    if (typeof modName !== "string") {
+        throw new CliError(`info.json file at ${infoJsonFile} does not contain a string property "name".`);
+    }
+    const resultPath = path.join(modsDir, modName);
+    const stat = await fsp.stat(resultPath).catch(() => undefined);
+    if (stat)
+        await fsp.rm(resultPath, { recursive: true });
+    await fsp.symlink(modPath, resultPath, "junction");
+    return modName;
+}
+async function configureModName(modsDir, modName) {
+    const exists = await checkModExists(modsDir, modName);
+    if (!exists) {
+        throw new CliError(`Mod ${modName} not found in ${modsDir}.`);
+    }
+}
+export async function checkModExists(modsDir, modName) {
+    const stat = await fsp.stat(modsDir).catch(() => undefined);
+    if (!stat?.isDirectory())
+        return false;
+    const files = await fsp.readdir(modsDir);
+    return files.some((f) => {
+        const fileStat = fs.statSync(path.join(modsDir, f), { throwIfNoEntry: false });
+        if (fileStat?.isDirectory()) {
+            return f === modName || f.match(new RegExp(`^${modName}_\\d+\\.\\d+\\.\\d+$`));
+        }
+        if (fileStat?.isFile()) {
+            return f === modName + ".zip" || f.match(new RegExp(`^${modName}_\\d+\\.\\d+\\.\\d+\\.zip$`));
+        }
+        return false;
+    });
+}
+async function getInstalledModVersion(modsDir, modName) {
+    const stat = await fsp.stat(modsDir).catch(() => undefined);
+    if (!stat?.isDirectory())
+        return undefined;
+    const files = await fsp.readdir(modsDir);
+    for (const f of files) {
+        const fullPath = path.join(modsDir, f);
+        const fileStat = fs.statSync(fullPath, { throwIfNoEntry: false });
+        if (fileStat?.isDirectory()) {
+            if (f === modName) {
+                const infoPath = path.join(fullPath, "info.json");
+                try {
+                    const info = JSON.parse(await fsp.readFile(infoPath, "utf8"));
+                    if (info.version)
+                        return info.version;
+                }
+                catch {
+                    continue;
+                }
+            }
+            const versionedMatch = f.match(new RegExp(`^${modName}_(\\d+\\.\\d+\\.\\d+)$`));
+            if (versionedMatch) {
+                const infoPath = path.join(fullPath, "info.json");
+                try {
+                    const info = JSON.parse(await fsp.readFile(infoPath, "utf8"));
+                    if (info.version)
+                        return info.version;
+                }
+                catch {
+                    return versionedMatch[1];
+                }
+            }
+        }
+        if (fileStat?.isFile()) {
+            const zipMatch = f.match(new RegExp(`^${modName}_(\\d+\\.\\d+\\.\\d+)\\.zip$`));
+            if (zipMatch)
+                return zipMatch[1];
+        }
+    }
+    return undefined;
+}
+export async function installFactorioTest(modsDir) {
+    await fsp.mkdir(modsDir, { recursive: true });
+    const playerDataPath = getFactorioPlayerDataPath();
+    let version = await getInstalledModVersion(modsDir, "factorio-test");
+    if (!version) {
+        console.log("Downloading factorio-test from mod portal using fmtk.");
+        await runScript("fmtk", "mods", "install", "--modsPath", modsDir, "--playerData", playerDataPath, "factorio-test");
+        version = await getInstalledModVersion(modsDir, "factorio-test");
+    }
+    else if (compareVersions(version, MIN_FACTORIO_TEST_VERSION) < 0) {
+        console.log(`factorio-test ${version} is outdated, downloading latest version.`);
+        await runScript("fmtk", "mods", "install", "--force", "--modsPath", modsDir, "--playerData", playerDataPath, "factorio-test");
+        version = await getInstalledModVersion(modsDir, "factorio-test");
+    }
+    if (!version || compareVersions(version, MIN_FACTORIO_TEST_VERSION) < 0) {
+        throw new CliError(`factorio-test mod version ${version ?? "unknown"} is below minimum required ${MIN_FACTORIO_TEST_VERSION}`);
+    }
+}
+export async function ensureConfigIni(dataDir) {
+    const filePath = path.join(dataDir, "config.ini");
+    if (!fs.existsSync(filePath)) {
+        console.log("Creating config.ini file");
+        await fsp.writeFile(filePath, `; This file was auto-generated by factorio-test cli
+
+[path]
+read-data=__PATH__executable__/../../data
+write-data=${dataDir}
+
+[general]
+locale=
+`);
+    }
+    else {
+        const content = await fsp.readFile(filePath, "utf8");
+        const newContent = content.replace(/^write-data=.*$/m, `write-data=${dataDir}`);
+        if (content !== newContent) {
+            await fsp.writeFile(filePath, newContent);
+        }
+    }
+}
+export async function setSettingsForAutorun(factorioPath, dataDir, modsDir, modToTest, mode, options) {
+    const settingsDat = path.join(modsDir, "mod-settings.dat");
+    if (!fs.existsSync(settingsDat)) {
+        if (options?.verbose)
+            console.log("Creating mod-settings.dat file by running factorio");
+        const dummySaveFile = path.join(dataDir, "____dummy_save_file.zip");
+        await runProcess(false, factorioPath, "--create", dummySaveFile, "--mod-directory", modsDir, "-c", path.join(dataDir, "config.ini"));
+        if (fs.existsSync(dummySaveFile)) {
+            await fsp.rm(dummySaveFile);
+        }
+    }
+    if (options?.verbose)
+        console.log("Setting autorun settings");
+    const autoStartConfig = JSON.stringify({
+        mod: modToTest,
+        headless: mode === "headless",
+        ...(options?.lastFailedTests?.length && { last_failed_tests: options.lastFailedTests }),
+    });
+    await runScript("fmtk", "settings", "set", "startup", "factorio-test-auto-start-config", autoStartConfig, "--modsPath", modsDir);
+    await runScript("fmtk", "settings", "unset", "startup", "factorio-test-auto-start", "--modsPath", modsDir);
+}
+export async function resetAutorunSettings(modsDir, verbose) {
+    if (verbose)
+        console.log("Disabling auto-start settings");
+    await runScript("fmtk", "settings", "set", "startup", "factorio-test-auto-start-config", "{}", "--modsPath", modsDir);
+}
+export function parseRequiredDependencies(dependencies) {
+    const result = [];
+    for (const dep of dependencies) {
+        const trimmed = dep.trim();
+        if (trimmed.startsWith("?") || trimmed.startsWith("!") || trimmed.startsWith("(?)")) {
+            continue;
+        }
+        const withoutPrefix = trimmed.startsWith("~") ? trimmed.slice(1).trim() : trimmed;
+        const modName = withoutPrefix.split(/\s/)[0];
+        if (modName && modName !== "base") {
+            result.push(modName);
+        }
+    }
+    return result;
+}
+export async function installModDependencies(modsDir, modPath, verbose) {
+    const infoJsonPath = path.join(modPath, "info.json");
+    let infoJson;
+    try {
+        infoJson = JSON.parse(await fsp.readFile(infoJsonPath, "utf8"));
+    }
+    catch {
+        return [];
+    }
+    const dependencies = infoJson.dependencies;
+    if (!Array.isArray(dependencies))
+        return [];
+    const required = parseRequiredDependencies(dependencies);
+    const playerDataPath = getFactorioPlayerDataPath();
+    for (const modName of required) {
+        const exists = await checkModExists(modsDir, modName);
+        if (exists)
+            continue;
+        if (verbose)
+            console.log(`Installing dependency: ${modName}`);
+        await runScript("fmtk", "mods", "install", "--modsPath", modsDir, "--playerData", playerDataPath, modName);
+    }
+    return required;
+}
+export async function resolveModWatchTarget(modsDir, modPath, modName) {
+    if (modPath) {
+        return { type: "directory", path: path.resolve(modPath) };
+    }
+    const files = await fsp.readdir(modsDir);
+    for (const file of files) {
+        const fullPath = path.join(modsDir, file);
+        const fileStat = await fsp.lstat(fullPath).catch(() => undefined);
+        if (!fileStat)
+            continue;
+        const isDirectoryMatch = fileStat.isDirectory() || fileStat.isSymbolicLink()
+            ? file === modName || file.match(new RegExp(`^${modName}_\\d+\\.\\d+\\.\\d+$`))
+            : false;
+        if (isDirectoryMatch) {
+            const targetPath = fileStat.isSymbolicLink() ? await fsp.realpath(fullPath) : fullPath;
+            return { type: "directory", path: targetPath };
+        }
+        const isFileMatch = fileStat.isFile()
+            ? file === modName + ".zip" || file.match(new RegExp(`^${modName}_\\d+\\.\\d+\\.\\d+\\.zip$`))
+            : false;
+        if (isFileMatch) {
+            return { type: "file", path: fullPath };
+        }
+    }
+    throw new CliError(`Could not find mod ${modName} in ${modsDir} for watching`);
+}

package/mod-setup.test.js

@@ -0,0 +1,30 @@
+import { describe, it, expect } from "vitest";
+import { parseRequiredDependencies } from "./mod-setup.js";
+describe("parseRequiredDependencies", () => {
+    it.each([
+        [[], []],
+        [["some-mod"], ["some-mod"]],
+        [["some-mod >= 1.0.0"], ["some-mod"]],
+        [["~ some-mod >= 1.0.0"], ["some-mod"]],
+        [["? optional-mod >= 1.0.0"], []],
+        [["! incompatible-mod"], []],
+        [["(?) hidden-optional >= 1.0.0"], []],
+        [["base >= 1.1.0"], []],
+        [["  mod-name  >=  1.0.0  "], ["mod-name"]],
+        [["~  soft-mod"], ["soft-mod"]],
+        [
+            [
+                "base >= 1.1.0",
+                "required-mod >= 2.0.0",
+                "? optional-mod",
+                "! incompatible-mod",
+                "(?) hidden-optional",
+                "~ soft-required >= 1.0.0",
+                "another-required",
+            ],
+            ["required-mod", "soft-required", "another-required"],
+        ],
+    ])("parseRequiredDependencies(%j) => %j", (input, expected) => {
+        expect(parseRequiredDependencies(input)).toEqual(expected);
+    });
+});

package/output-formatter.js

@@ -0,0 +1,94 @@
+import chalk from "chalk";
+function formatDuration(ms) {
+    if (ms >= 1000) {
+        return `${(ms / 1000).toFixed(2)}s`;
+    }
+    return `${ms.toFixed(1)}ms`;
+}
+export class OutputFormatter {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    formatTestResult(test) {
+        if (this.options.quiet)
+            return;
+        const showLogs = test.result === "failed" || this.options.showPassedLogs;
+        if (showLogs && test.logs.length > 0) {
+            for (const log of test.logs) {
+                console.log("    " + log);
+            }
+        }
+        const prefix = this.getPrefix(test.result);
+        const duration = test.durationMs !== undefined ? ` (${formatDuration(test.durationMs)})` : "";
+        console.log(`${prefix} ${test.path}${duration}`);
+        if (test.result === "failed") {
+            for (const error of test.errors) {
+                console.log("    " + error);
+            }
+        }
+    }
+    formatSummary(data) {
+        if (!data.summary)
+            return;
+        const { status } = data.summary;
+        const color = status === "passed" ? chalk.greenBright : status === "todo" ? chalk.yellowBright : chalk.redBright;
+        console.log("Test run result:", color(status));
+    }
+    getPrefix(result) {
+        switch (result) {
+            case "passed":
+                return chalk.green("PASS");
+            case "failed":
+                return chalk.red("FAIL");
+            case "skipped":
+                return chalk.yellow("SKIP");
+            case "todo":
+                return chalk.magenta("TODO");
+        }
+    }
+}
+export class OutputPrinter {
+    options;
+    formatter;
+    isMessageFirstLine = true;
+    constructor(options) {
+        this.options = options;
+        this.formatter = new OutputFormatter({
+            verbose: options.verbose,
+            quiet: options.quiet,
+            showPassedLogs: options.verbose,
+        });
+    }
+    printTestResult(test) {
+        if (this.options.quiet || this.options.useProgressBar)
+            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;
+        if (this.isMessageFirstLine) {
+            console.log(line.slice(line.indexOf(": ") + 2));
+            this.isMessageFirstLine = false;
+        }
+        else {
+            console.log("    " + line);
+        }
+    }
+    resetMessage() {
+        this.isMessageFirstLine = true;
+    }
+    printVerbose(line) {
+        if (this.options.verbose) {
+            console.log(line);
+        }
+    }
+}

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.0",
+  "version": "3.0.0",
   "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);
+    }
+}