factorio-test-cli 2.0.1 → 3.0.1

package/factorio-process.js

@@ -0,0 +1,165 @@
+import { spawn } from "child_process";
+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 { CliError } from "./cli-error.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export function getHeadlessSavePath(overridePath) {
+    if (overridePath) {
+        return path.resolve(overridePath);
+    }
+    return path.join(__dirname, "headless-save.zip");
+}
+export function parseResultMessage(message) {
+    if (message.endsWith(":focused")) {
+        return {
+            status: message.slice(0, -":focused".length),
+            hasFocusedTests: true,
+        };
+    }
+    return {
+        status: message,
+        hasFocusedTests: false,
+    };
+}
+function createOutputComponents(options) {
+    const handler = new FactorioOutputHandler();
+    const collector = new TestRunCollector();
+    const printer = new OutputPrinter({
+        verbose: options.verbose,
+        quiet: options.quiet,
+    });
+    const progress = new ProgressRenderer();
+    handler.on("event", (event) => {
+        collector.handleEvent(event);
+        progress.handleEvent(event);
+        if (options.verbose) {
+            progress.withPermanentOutput(() => console.log(JSON.stringify(event)));
+        }
+    });
+    handler.on("log", (line) => {
+        collector.captureLog(line);
+        progress.withPermanentOutput(() => printer.printVerbose(line));
+    });
+    handler.on("message", (line) => {
+        progress.withPermanentOutput(() => printer.printMessage(line));
+    });
+    collector.on("testFinished", (test) => {
+        progress.handleTestFinished(test);
+        progress.withPermanentOutput(() => printer.printTestResult(test));
+    });
+    return { handler, collector, printer, progress };
+}
+export async function runFactorioTestsHeadless(factorioPath, dataDir, savePath, additionalArgs, options) {
+    const args = [
+        "--benchmark",
+        savePath,
+        "--benchmark-ticks",
+        "1000000000",
+        "--mod-directory",
+        path.join(dataDir, "mods"),
+        "-c",
+        path.join(dataDir, "config.ini"),
+        ...additionalArgs,
+    ];
+    console.log("Running tests (headless)...");
+    const factorioProcess = spawn(factorioPath, args, {
+        stdio: ["inherit", "pipe", "pipe"],
+    });
+    const { handler, collector, printer, progress } = createOutputComponents(options);
+    let resultMessage;
+    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;
+            clearTimeout(startupTimeout);
+        }
+    });
+    const startupTimeout = setTimeout(() => {
+        if (!testRunStarted) {
+            startupTimedOut = true;
+            factorioProcess.kill();
+        }
+    }, 10_000);
+    const abortHandler = () => {
+        wasCancelled = true;
+        factorioProcess.kill();
+    };
+    options.signal?.addEventListener("abort", abortHandler);
+    new BufferLineSplitter(factorioProcess.stdout).on("line", (line) => handler.handleLine(line));
+    new BufferLineSplitter(factorioProcess.stderr).on("line", (line) => handler.handleLine(line));
+    await new Promise((resolve, reject) => {
+        factorioProcess.on("exit", (code, signal) => {
+            clearTimeout(startupTimeout);
+            options.signal?.removeEventListener("abort", abortHandler);
+            if (wasCancelled) {
+                resolve();
+            }
+            else if (startupTimedOut) {
+                reject(new CliError("Factorio unresponsive: no test run started within 10 seconds"));
+            }
+            else if (resultMessage !== undefined) {
+                resolve();
+            }
+            else {
+                reject(new CliError(`Factorio exited with code ${code}, signal ${signal}, no result received`));
+            }
+        });
+    });
+    if (wasCancelled) {
+        return { status: "cancelled", hasFocusedTests: false };
+    }
+    const parsed = parseResultMessage(resultMessage);
+    return { ...parsed, message: resultMessage, data: collector.getData() };
+}
+export async function runFactorioTestsGraphics(factorioPath, dataDir, savePath, additionalArgs, options) {
+    const args = [
+        "--load-game",
+        savePath,
+        "--mod-directory",
+        path.join(dataDir, "mods"),
+        "-c",
+        path.join(dataDir, "config.ini"),
+        ...additionalArgs,
+    ];
+    console.log("Running tests (graphics)...");
+    const factorioProcess = spawn(factorioPath, args, {
+        stdio: ["inherit", "pipe", "inherit"],
+    });
+    const { handler, collector, printer, progress } = createOutputComponents(options);
+    let resultMessage;
+    let resolvePromise;
+    handler.on("result", (msg) => {
+        resultMessage = msg;
+        progress.finish();
+        printer.resetMessage();
+        if (options.resolveOnResult && resolvePromise) {
+            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) {
+                resolve();
+            }
+            else {
+                reject(new CliError(`Factorio exited with code ${code}, signal ${signal}`));
+            }
+        });
+    });
+    const parsed = parseResultMessage(resultMessage);
+    return { ...parsed, message: resultMessage, data: collector.getData() };
+}

package/factorio-process.test.js

@@ -0,0 +1,15 @@
+import { describe, it, expect } from "vitest";
+import { parseResultMessage } from "./factorio-process.js";
+describe("parseResultMessage", () => {
+    it.each([
+        ["passed", { status: "passed", hasFocusedTests: false }],
+        ["failed", { status: "failed", hasFocusedTests: false }],
+        ["todo", { status: "todo", hasFocusedTests: false }],
+        ["loadError", { status: "loadError", hasFocusedTests: false }],
+        ["passed:focused", { status: "passed", hasFocusedTests: true }],
+        ["failed:focused", { status: "failed", hasFocusedTests: true }],
+        ["todo:focused", { status: "todo", hasFocusedTests: true }],
+    ])("parses %s", (input, expected) => {
+        expect(parseResultMessage(input)).toEqual(expected);
+    });
+});

package/file-watcher.js

@@ -0,0 +1,36 @@
+import * as fs from "fs";
+import { minimatch } from "minimatch";
+export function matchesPattern(filename, patterns) {
+    const normalizedFilename = filename.replace(/\\/g, "/");
+    return patterns.some((pattern) => minimatch(normalizedFilename, pattern));
+}
+export function watchDirectory(dir, onChange, options) {
+    const debounceMs = options.debounceMs ?? 300;
+    let timeout;
+    const debouncedOnChange = () => {
+        if (timeout)
+            clearTimeout(timeout);
+        timeout = setTimeout(onChange, debounceMs);
+    };
+    const watcher = fs.watch(dir, { recursive: true }, (_, filename) => {
+        if (!filename)
+            return;
+        if (matchesPattern(filename, options.patterns)) {
+            debouncedOnChange();
+        }
+    });
+    return watcher;
+}
+export function watchFile(filePath, onChange, options) {
+    const debounceMs = options?.debounceMs ?? 300;
+    let timeout;
+    const debouncedOnChange = () => {
+        if (timeout)
+            clearTimeout(timeout);
+        timeout = setTimeout(onChange, debounceMs);
+    };
+    const watcher = fs.watch(filePath, () => {
+        debouncedOnChange();
+    });
+    return watcher;
+}

package/file-watcher.test.js

@@ -0,0 +1,29 @@
+import { describe, it, expect } from "vitest";
+import { matchesPattern } from "./file-watcher.js";
+describe("matchesPattern", () => {
+    const defaultPatterns = ["info.json", "**/*.lua"];
+    it.each([
+        ["info.json", defaultPatterns, true],
+        ["control.lua", defaultPatterns, true],
+        ["nested/file.lua", defaultPatterns, true],
+        ["deeply/nested/module.lua", defaultPatterns, true],
+        ["data.ts", defaultPatterns, false],
+        ["settings.json", defaultPatterns, false],
+        ["info.json.bak", defaultPatterns, false],
+        ["some/info.json", defaultPatterns, false],
+    ])("matchesPattern(%j, %j) => %j", (filename, patterns, expected) => {
+        expect(matchesPattern(filename, patterns)).toBe(expected);
+    });
+    it("handles custom patterns", () => {
+        expect(matchesPattern("src/main.ts", ["**/*.ts"])).toBe(true);
+        expect(matchesPattern("main.ts", ["**/*.ts"])).toBe(true);
+        expect(matchesPattern("main.js", ["**/*.ts"])).toBe(false);
+    });
+    it("handles single wildcard", () => {
+        expect(matchesPattern("file.lua", ["*.lua"])).toBe(true);
+        expect(matchesPattern("nested/file.lua", ["*.lua"])).toBe(false);
+    });
+    it("handles backslash paths (Windows)", () => {
+        expect(matchesPattern("nested\\file.lua", defaultPatterns)).toBe(true);
+    });
+});

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