factorio-test-cli 3.3.1 → 3.5.0

package/config/cli-config.js

@@ -131,6 +131,7 @@ export function registerAllCliOptions(command) {
     command.option("-c --config <path>", "Path to config file (default: factorio-test.json, or 'factorio-test' key in package.json)");
     command.option("-g --graphics", "Launch Factorio with graphics (interactive mode) instead of headless");
     command.option("-w --watch", "Watch for file changes and rerun tests");
+    command.option("--no-auto-start", "Configure tests but do not auto-start them (requires --graphics)");
     addOption(command, f.modPath.cli);
     addOption(command, f.modName.cli);
     addOption(command, f.factorioPath.cli);

package/config/loader.js

@@ -58,6 +58,7 @@ export function resolveConfig({ cliOptions, patterns }) {
     return {
         graphics: cliOptions.graphics,
         watch: cliOptions.watch,
+        noAutoStart: cliOptions.autoStart === false ? true : undefined,
         modPath: baseConfig.modPath,
         modName: baseConfig.modName,
         factorioPath: baseConfig.factorioPath,

package/factorio-process.js

@@ -118,7 +118,7 @@ function createOutputComponents(options) {
         collector.handleEvent(event);
         progress.handleEvent(event);
         if (options.verbose) {
-            progress.withPermanentOutput(() => console.log(JSON.stringify(event)));
+            progress.withPermanentOutput(() => printer.printEvent(event));
         }
     });
     handler.on("log", (line) => {

package/mod-setup.js

@@ -154,17 +154,20 @@ locale=
         }
     }
 }
-export async function setSettingsForAutorun(factorioPath, dataDir, modsDir, modToTest, mode, options) {
+export async function ensureModSettingsDat(factorioPath, dataDir, modsDir, verbose) {
     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 (fs.existsSync(settingsDat))
+        return;
+    if (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);
     }
+}
+export async function setSettingsForAutorun(factorioPath, dataDir, modsDir, modToTest, mode, options) {
+    await ensureModSettingsDat(factorioPath, dataDir, modsDir, options?.verbose);
     if (options?.verbose)
         console.log("Setting autorun settings");
     const autoStartConfig = JSON.stringify({

package/package.json

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

package/run.js

@@ -8,7 +8,7 @@ import { registerAllCliOptions, resolveConfig } 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, installMods, parseModRequirement, resetAutorunSettings, resolveModWatchTarget, setSettingsForAutorun, } from "./mod-setup.js";
+import { configureModToTest, ensureConfigIni, ensureModSettingsDat, installFactorioTest, installModDependencies, installMods, parseModRequirement, resetAutorunSettings, resolveModWatchTarget, setSettingsForAutorun, } from "./mod-setup.js";
 import { runScript, setVerbose } from "./process-utils.js";
 import { OutputFormatter } from "./test-output.js";
 import { readPreviousFailedTests, writeResultsFile } from "./test-results.js";
@@ -47,6 +47,9 @@ async function setupTestRun(patterns, cliOptions) {
     if (config.modPath === undefined && config.modName === undefined) {
         throw new CliError("One of --mod-path or --mod-name must be specified.");
     }
+    if (config.noAutoStart && !config.graphics) {
+        throw new CliError("--no-auto-start requires --graphics.");
+    }
     const factorioPath = config.factorioPath ?? autoDetectFactorioPath();
     const dataDir = config.dataDirectory;
     const modsDir = path.join(dataDir, "mods");
@@ -191,9 +194,24 @@ async function runHeadlessWatchMode(ctx) {
     });
     return new Promise(() => { });
 }
+async function launchWithoutAutoStart(ctx) {
+    const { config, factorioPath, dataDir, modsDir, modToTest, savePath, factorioArgs } = ctx;
+    await ensureModSettingsDat(factorioPath, dataDir, modsDir, config.verbose);
+    await runScript("fmtk", "settings", "set", "runtime-global", "factorio-test-mod-to-test", modToTest, "--modsPath", modsDir);
+    if (Object.keys(config.testConfig).length > 0) {
+        await runScript("fmtk", "settings", "set", "runtime-global", "factorio-test-config", JSON.stringify(config.testConfig), "--modsPath", modsDir);
+    }
+    await runFactorioTestsGraphics(factorioPath, dataDir, savePath, factorioArgs, {
+        verbose: config.verbose,
+        quiet: config.quiet,
+    });
+}
 async function runTests(patterns, cliOptions) {
     const ctx = await setupTestRun(patterns, cliOptions);
-    if (ctx.config.watch && ctx.config.graphics) {
+    if (ctx.config.noAutoStart) {
+        await launchWithoutAutoStart(ctx);
+    }
+    else if (ctx.config.watch && ctx.config.graphics) {
         await runGraphicsWatchMode(ctx);
     }
     else if (ctx.config.watch) {

package/test-output.js

@@ -90,7 +90,8 @@ export class OutputFormatter {
         const prefix = this.getPrefix(test.result);
         const duration = test.durationMs !== undefined ? ` (${formatDuration(test.durationMs)})` : "";
         console.log(`${prefix} ${test.path}${duration}`);
-        const showLogs = test.result === "failed" || test.result === "error" || this.options.showPassedLogs;
+        const showLogs = this.options.showLogs !== false &&
+            (test.result === "failed" || test.result === "error" || this.options.showPassedLogs);
         if (showLogs && test.logs.length > 0) {
             console.log("Log messages:");
             for (const log of test.logs) {
@@ -139,6 +140,20 @@ export class OutputFormatter {
         const total = summary.passed + summary.failed + summary.skipped + summary.todo;
         console.log(`Tests: ${segments.join(", ")} (${total} total)`);
     }
+    formatEvent(event) {
+        switch (event.type) {
+            case "testRunStarted":
+                return chalk.dim(`Running ${event.total} tests...`);
+            case "testStarted":
+                return chalk.dim(`Starting: ${event.test.path}`);
+            case "loadError":
+                return chalk.red(`Load error: ${event.error}`);
+            case "testRunCancelled":
+                return chalk.yellow("Test run cancelled");
+            default:
+                return undefined;
+        }
+    }
     getPrefix(result) {
         switch (result) {
             case "passed":
@@ -164,6 +179,7 @@ export class OutputPrinter {
             verbose: options.verbose,
             quiet: options.quiet,
             showPassedLogs: options.verbose,
+            showLogs: !options.verbose,
         });
     }
     printTestResult(test) {
@@ -187,6 +203,12 @@ export class OutputPrinter {
     resetMessage() {
         this.isMessageFirstLine = true;
     }
+    printEvent(event) {
+        const formatted = this.formatter.formatEvent(event);
+        if (formatted !== undefined) {
+            console.log(formatted);
+        }
+    }
     printVerbose(line) {
         if (this.options.verbose) {
             console.log(line);

package/test-output.test.js

@@ -223,6 +223,104 @@ describe("OutputFormatter", () => {
         expect(output.some((line) => line.includes("Oh no"))).toBe(true);
     });
 });
+describe("OutputFormatter.formatEvent", () => {
+    it("formats testRunStarted", () => {
+        const formatter = new OutputFormatter({});
+        const result = formatter.formatEvent({ type: "testRunStarted", total: 42 });
+        expect(result).toContain("Running 42 tests...");
+    });
+    it("formats testStarted", () => {
+        const formatter = new OutputFormatter({});
+        const result = formatter.formatEvent({ type: "testStarted", test: { path: "root > my test" } });
+        expect(result).toContain("Starting: root > my test");
+    });
+    it("formats loadError", () => {
+        const formatter = new OutputFormatter({});
+        const result = formatter.formatEvent({ type: "loadError", error: "syntax error in foo.lua" });
+        expect(result).toContain("Load error: syntax error in foo.lua");
+    });
+    it("formats testRunCancelled", () => {
+        const formatter = new OutputFormatter({});
+        const result = formatter.formatEvent({ type: "testRunCancelled" });
+        expect(result).toContain("Test run cancelled");
+    });
+    it("returns undefined for testPassed", () => {
+        const formatter = new OutputFormatter({});
+        const result = formatter.formatEvent({ type: "testPassed", test: { path: "test" } });
+        expect(result).toBeUndefined();
+    });
+    it("returns undefined for testFailed", () => {
+        const formatter = new OutputFormatter({});
+        const result = formatter.formatEvent({ type: "testFailed", test: { path: "test" }, errors: ["err"] });
+        expect(result).toBeUndefined();
+    });
+    it("returns undefined for testRunFinished", () => {
+        const formatter = new OutputFormatter({});
+        const result = formatter.formatEvent({
+            type: "testRunFinished",
+            results: {
+                ran: 1,
+                passed: 1,
+                failed: 0,
+                skipped: 0,
+                todo: 0,
+                cancelled: 0,
+                describeBlockErrors: 0,
+                status: "passed",
+            },
+        });
+        expect(result).toBeUndefined();
+    });
+});
+describe("OutputFormatter showLogs option", () => {
+    let consoleSpy;
+    let output;
+    beforeEach(() => {
+        output = [];
+        consoleSpy = vi.spyOn(console, "log").mockImplementation((...args) => {
+            output.push(args.join(" "));
+        });
+    });
+    afterEach(() => {
+        consoleSpy.mockRestore();
+    });
+    it("showLogs: false suppresses logs for failed tests", () => {
+        const formatter = new OutputFormatter({ showLogs: false });
+        const test = {
+            path: "test",
+            result: "failed",
+            errors: ["assertion failed"],
+            logs: ["debug output"],
+        };
+        formatter.formatTestResult(test);
+        expect(output.some((l) => l.includes("Log messages:"))).toBe(false);
+        expect(output.some((l) => l.includes("debug output"))).toBe(false);
+    });
+    it("showLogs: false still shows errors", () => {
+        const formatter = new OutputFormatter({ showLogs: false });
+        const test = {
+            path: "test",
+            result: "failed",
+            errors: ["assertion failed"],
+            logs: ["debug output"],
+        };
+        formatter.formatTestResult(test);
+        expect(output.some((l) => l.includes("Errors:"))).toBe(true);
+        expect(output.some((l) => l.includes("assertion failed"))).toBe(true);
+    });
+    it("showLogs: false suppresses logs for error results", () => {
+        const formatter = new OutputFormatter({ showLogs: false });
+        const test = {
+            path: "block",
+            result: "error",
+            errors: ["hook error"],
+            logs: ["hook log"],
+        };
+        formatter.formatTestResult(test);
+        expect(output.some((l) => l.includes("hook log"))).toBe(false);
+        expect(output.some((l) => l.includes("hook error"))).toBe(true);
+    });
+});
 describe("OutputFormatter.formatSummary", () => {
     let consoleSpy;
     let output;
@@ -403,6 +501,29 @@ describe("OutputPrinter", () => {
         expect(output.some((line) => line.includes("FAIL"))).toBe(true);
         expect(output.some((line) => line.includes("TODO"))).toBe(true);
     });
+    it("verbose mode: printEvent prints formatted events", () => {
+        const printer = new OutputPrinter({ verbose: true });
+        printer.printEvent({ type: "testStarted", test: { path: "root > test" } });
+        expect(output.some((l) => l.includes("Starting: root > test"))).toBe(true);
+    });
+    it("verbose mode: printEvent skips events that return undefined", () => {
+        const printer = new OutputPrinter({ verbose: true });
+        printer.printEvent({ type: "testPassed", test: { path: "test" } });
+        expect(output).toHaveLength(0);
+    });
+    it("verbose mode: printTestResult does not include logs", () => {
+        const printer = new OutputPrinter({ verbose: true });
+        const test = {
+            path: "test",
+            result: "failed",
+            errors: ["err"],
+            logs: ["debug log"],
+        };
+        printer.printTestResult(test);
+        expect(output.some((l) => l.includes("FAIL"))).toBe(true);
+        expect(output.some((l) => l.includes("debug log"))).toBe(false);
+        expect(output.some((l) => l.includes("err"))).toBe(true);
+    });
     it("hides all tests in quiet mode", () => {
         const printer = new OutputPrinter({ quiet: true });
         printer.printTestResult(passedTest);