factorio-test-cli 2.0.1 → 3.0.1

package/README.md

@@ -9,3 +9,60 @@ If using an npm package, you can install `factorio-test-cli` to your dev depende
 ```bash
 npm install --save-dev factorio-test-cli
 ```
+
+## Configuration Architecture
+
+### Config Categories
+
+| Category | Casing | Location | Example Fields |
+|----------|--------|----------|----------------|
+| CLI-only | camelCase | `cli-config.ts` | `config`, `graphics`, `watch` |
+| File+CLI | camelCase | `cli-config.ts` | `modPath`, `factorioPath`, `verbose`, `forbidOnly` |
+| Test | snake_case | `types/config.d.ts` | `test_pattern`, `game_speed`, `bail` |
+
+- **CLI-only**: Options only available via command line, not in config files
+- **File+CLI**: Options that can be set in `factorio-test.json` or via command line (CLI overrides file)
+- **Test**: Runner configuration passed to the Factorio mod; uses snake_case for Lua compatibility
+
+### Type Hierarchy
+
+```
+types/config.d.ts
+└── TestRunnerConfig        # CLI-passable fields (source of truth)
+        │
+        ├── Extended by: FactorioTest.Config (types/index.d.ts)
+        │                 └── Adds mod-only fields: default_ticks_between_tests,
+        │                     before_test_run, after_test_run, sound_effects
+        │
+        └── Validated by: testRunnerConfigSchema (cli/config/test-config.ts)
+                          └── Zod schema for runtime validation
+```
+
+### Data Flow
+
+```
+CLI args ─────────────────┐
+                          ▼
+factorio-test.json ──► loadConfig() ──► mergeCliConfig() ──► RunOptions
+                                              │
+                                              ▼
+                                        buildTestConfig() ──► TestRunnerConfig ──► Factorio mod
+```
+
+1. `loadConfig()` reads `factorio-test.json` (or `package.json["factorio-test"]`)
+2. `mergeCliConfig()` merges file config with CLI options (CLI wins)
+3. `buildTestConfig()` extracts test runner options, combining patterns with OR logic
+
+### File Organization
+
+```
+types/
+├── config.d.ts       # TestRunnerConfig interface (source of truth for CLI-passable test options)
+└── index.d.ts        # FactorioTest.Config extends TestRunnerConfig with mod-only fields
+
+cli/config/
+├── index.ts          # Re-exports all public APIs
+├── test-config.ts    # Zod schema validating TestRunnerConfig + CLI registration
+├── cli-config.ts     # CliConfig + CliOnlyOptions schemas + CLI registration
+└── loader.ts         # Config loading, path resolution, merging, RunOptions type
+```

package/cli-error.js

@@ -0,0 +1,6 @@
+export class CliError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "CliError";
+    }
+}

package/cli.js

@@ -1,10 +1,21 @@
 #!/usr/bin/env node
 import { program } from "commander";
+import chalk from "chalk";
+import { CliError } from "./cli-error.js";
 import "./run.js";
-await program
-    .name("factorio-test")
-    .description("cli for factorio testing")
-    .helpCommand(true)
-    .showHelpAfterError()
-    .showSuggestionAfterError()
-    .parseAsync();
+try {
+    await program
+        .name("factorio-test")
+        .description("cli for factorio testing")
+        .helpCommand(true)
+        .showHelpAfterError()
+        .showSuggestionAfterError()
+        .parseAsync();
+}
+catch (error) {
+    if (error instanceof CliError) {
+        console.error(chalk.red("Error:"), error.message);
+        process.exit(1);
+    }
+    throw error;
+}

package/config/cli-config.js

@@ -0,0 +1,142 @@
+import { z } from "zod";
+import { testRunnerConfigSchema, registerTestConfigOptions } from "./test-config.js";
+export const DEFAULT_DATA_DIRECTORY = "./factorio-test-data-dir";
+const cliConfigFields = {
+    modPath: {
+        schema: z.string().optional(),
+        cli: {
+            flags: "-p --mod-path <path>",
+            description: "[one required] Path to the mod folder (containing info.json). Will create a symlink from mods folder to here.",
+        },
+    },
+    modName: {
+        schema: z.string().optional(),
+        cli: {
+            flags: "--mod-name <name>",
+            description: "[one required] Name of a mod already in the configured data directory.",
+        },
+    },
+    factorioPath: {
+        schema: z.string().optional(),
+        cli: {
+            flags: "--factorio-path <path>",
+            description: "Path to the Factorio binary. If not specified, will attempt to be auto-detected.",
+        },
+    },
+    dataDirectory: {
+        schema: z.string().optional(),
+        cli: {
+            flags: "-d --data-directory <path>",
+            description: "Factorio data directory, where mods, saves, config etc. will be.",
+            default: DEFAULT_DATA_DIRECTORY,
+        },
+    },
+    save: {
+        schema: z.string().optional(),
+        cli: {
+            flags: "--save <path>",
+            description: "Path to save file. Default: uses a bundled save with empty lab-tile world.",
+        },
+    },
+    mods: {
+        schema: z.array(z.string()).optional(),
+        cli: {
+            flags: "--mods <mods...>",
+            description: "Additional mods to enable besides the mod under test (e.g., --mods mod1 mod2=1.2.3).",
+        },
+    },
+    factorioArgs: {
+        schema: z.array(z.string()).optional(),
+        cli: {
+            flags: "--factorio-args <args...>",
+            description: "Additional arguments to pass to Factorio process.",
+        },
+    },
+    verbose: {
+        schema: z.boolean().optional(),
+        cli: {
+            flags: "-v --verbose",
+            description: "Enable verbose logging; pipe Factorio output to stdout.",
+        },
+    },
+    quiet: {
+        schema: z.boolean().optional(),
+        cli: {
+            flags: "-q --quiet",
+            description: "Suppress per-test output, show only final result.",
+        },
+    },
+    outputFile: {
+        schema: z.string().optional(),
+        cli: {
+            flags: "--output-file <path>",
+            description: "Path for test results JSON file. Used to reorder failed tests first on subsequent runs.",
+        },
+    },
+    forbidOnly: {
+        schema: z.boolean().optional(),
+        cli: {
+            flags: "--forbid-only",
+            description: "Fail if .only tests are present (default: enabled). Useful for CI.",
+            negatable: true,
+        },
+    },
+    watchPatterns: {
+        schema: z.array(z.string()).optional(),
+        cli: {
+            flags: "--watch-patterns <patterns...>",
+            description: "Glob patterns to watch (default: info.json, **/*.lua).",
+        },
+    },
+    udpPort: {
+        schema: z.number().int().positive().optional(),
+        cli: {
+            flags: "--udp-port <port>",
+            description: "UDP port to use for --graphics --watch mode reload trigger (default: 14434).",
+            parseArg: (v) => parseInt(v, 10),
+        },
+    },
+};
+export const cliConfigSchema = z.object({
+    ...Object.fromEntries(Object.entries(cliConfigFields).map(([k, v]) => [k, v.schema])),
+    test: testRunnerConfigSchema.optional(),
+});
+function addOption(command, cli) {
+    if (cli.parseArg) {
+        command.option(cli.flags, cli.description, cli.parseArg, cli.default);
+    }
+    else if ("default" in cli && cli.default !== undefined) {
+        command.option(cli.flags, cli.description, cli.default);
+    }
+    else {
+        command.option(cli.flags, cli.description);
+    }
+    if (cli.negatable) {
+        const flagName = cli.flags
+            .split(" ")[0]
+            .replace(/^-+/, "")
+            .replace(/^[a-z] --/, "");
+        command.option(`--no-${flagName}`, `Disable ${flagName}`);
+    }
+}
+export function registerAllCliOptions(command) {
+    const f = cliConfigFields;
+    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");
+    addOption(command, f.modPath.cli);
+    addOption(command, f.modName.cli);
+    addOption(command, f.factorioPath.cli);
+    addOption(command, f.dataDirectory.cli);
+    addOption(command, f.save.cli);
+    addOption(command, f.mods.cli);
+    addOption(command, f.factorioArgs.cli);
+    registerTestConfigOptions(command);
+    addOption(command, f.verbose.cli);
+    addOption(command, f.quiet.cli);
+    addOption(command, f.outputFile.cli);
+    command.option("--no-output-file", "Disable writing test results file");
+    addOption(command, f.forbidOnly.cli);
+    addOption(command, f.watchPatterns.cli);
+    addOption(command, f.udpPort.cli);
+}

package/config/index.js

@@ -0,0 +1,3 @@
+export { testRunnerConfigSchema, parseCliTestOptions } from "./test-config.js";
+export { cliConfigSchema, registerAllCliOptions } from "./cli-config.js";
+export { loadConfig, mergeTestConfig, mergeCliConfig, buildTestConfig } from "./loader.js";

package/config/loader.js

@@ -0,0 +1,72 @@
+import * as fs from "fs";
+import * as path from "path";
+import { CliError } from "../cli-error.js";
+import { cliConfigSchema, DEFAULT_DATA_DIRECTORY } from "./cli-config.js";
+import { parseCliTestOptions } from "./test-config.js";
+function formatZodError(error, filePath) {
+    const issues = error.issues.map((issue) => {
+        const pathStr = issue.path.join(".");
+        return `  - ${pathStr ? `"${pathStr}": ` : ""}${issue.message}`;
+    });
+    return `Invalid config in ${filePath}:\n${issues.join("\n")}`;
+}
+export function loadConfig(configPath) {
+    const paths = configPath
+        ? [path.resolve(configPath)]
+        : [path.resolve("factorio-test.json"), path.resolve("package.json")];
+    for (const filePath of paths) {
+        if (!fs.existsSync(filePath))
+            continue;
+        const content = JSON.parse(fs.readFileSync(filePath, "utf8"));
+        const rawConfig = filePath.endsWith("package.json") ? content["factorio-test"] : content;
+        if (!rawConfig)
+            continue;
+        const result = cliConfigSchema.strict().safeParse(rawConfig);
+        if (!result.success) {
+            throw new CliError(formatZodError(result.error, filePath));
+        }
+        return resolveConfigPaths(result.data, path.dirname(filePath));
+    }
+    return {};
+}
+function resolveConfigPaths(config, configDir) {
+    return {
+        ...config,
+        modPath: config.modPath ? path.resolve(configDir, config.modPath) : undefined,
+        factorioPath: config.factorioPath ? path.resolve(configDir, config.factorioPath) : undefined,
+        dataDirectory: path.resolve(configDir, config.dataDirectory ?? DEFAULT_DATA_DIRECTORY),
+        save: config.save ? path.resolve(configDir, config.save) : undefined,
+    };
+}
+export function mergeTestConfig(configFile, cliOptions) {
+    return {
+        ...configFile,
+        test_pattern: cliOptions.test_pattern ?? configFile?.test_pattern,
+        tag_whitelist: cliOptions.tag_whitelist ?? configFile?.tag_whitelist,
+        tag_blacklist: cliOptions.tag_blacklist ?? configFile?.tag_blacklist,
+        default_timeout: cliOptions.default_timeout ?? configFile?.default_timeout,
+        game_speed: cliOptions.game_speed ?? configFile?.game_speed,
+        log_passed_tests: cliOptions.log_passed_tests ?? configFile?.log_passed_tests,
+        log_skipped_tests: cliOptions.log_skipped_tests ?? configFile?.log_skipped_tests,
+        reorder_failed_first: cliOptions.reorder_failed_first ?? configFile?.reorder_failed_first,
+        bail: cliOptions.bail ?? configFile?.bail,
+    };
+}
+export function mergeCliConfig(fileConfig, options) {
+    options.modPath ??= fileConfig.modPath;
+    options.modName ??= fileConfig.modName;
+    options.factorioPath ??= fileConfig.factorioPath;
+    options.dataDirectory ??= fileConfig.dataDirectory ?? DEFAULT_DATA_DIRECTORY;
+    options.mods ??= fileConfig.mods;
+    options.factorioArgs ??= fileConfig.factorioArgs;
+    options.verbose ??= fileConfig.verbose;
+    options.quiet ??= fileConfig.quiet;
+    return options;
+}
+export function buildTestConfig(fileConfig, options, patterns) {
+    const cliTestOptions = parseCliTestOptions(options);
+    const testPattern = patterns.length > 0
+        ? patterns.map((p) => `(${p})`).join("|")
+        : (cliTestOptions.test_pattern ?? fileConfig.test?.test_pattern);
+    return mergeTestConfig(fileConfig.test, { ...cliTestOptions, test_pattern: testPattern });
+}

package/config/test-config.js

@@ -0,0 +1,104 @@
+import { z } from "zod";
+const testConfigFields = {
+    test_pattern: {
+        schema: z.string().optional(),
+        cli: {
+            flags: "--test-pattern <pattern>",
+            description: "Filter tests by name pattern.",
+        },
+    },
+    tag_whitelist: {
+        schema: z.array(z.string()).optional(),
+        cli: {
+            flags: "--tag-whitelist <tags...>",
+            description: "Only run tests with these tags.",
+        },
+    },
+    tag_blacklist: {
+        schema: z.array(z.string()).optional(),
+        cli: {
+            flags: "--tag-blacklist <tags...>",
+            description: "Skip tests with these tags.",
+        },
+    },
+    default_timeout: {
+        schema: z.number().int().positive().optional(),
+        cli: {
+            flags: "--default-timeout <ticks>",
+            description: "Default async test timeout in ticks.",
+            parseArg: parseInt,
+        },
+    },
+    game_speed: {
+        schema: z.number().int().positive().optional(),
+        cli: {
+            flags: "--game-speed <speed>",
+            description: "Game speed multiplier.",
+            parseArg: parseInt,
+        },
+    },
+    bail: {
+        schema: z.number().int().positive().optional(),
+        cli: {
+            flags: "-b --bail [count]",
+            description: "Stop after n failures (default: 1 when flag present).",
+            parseArg: (v) => (v === undefined ? 1 : parseInt(v)),
+        },
+    },
+    reorder_failed_first: {
+        schema: z.boolean().optional(),
+        cli: {
+            flags: "--reorder-failed-first",
+            description: "Run previously failed tests first (default: enabled).",
+            negatable: true,
+        },
+    },
+    log_passed_tests: {
+        schema: z.boolean().optional(),
+        cli: {
+            flags: "--log-passed-tests",
+            description: "Log passed test names (default: enabled).",
+            negatable: true,
+        },
+    },
+    log_skipped_tests: {
+        schema: z.boolean().optional(),
+        cli: {
+            flags: "--log-skipped-tests",
+            description: "Log skipped test names.",
+        },
+    },
+};
+export const testRunnerConfigSchema = z.strictObject(Object.fromEntries(Object.entries(testConfigFields).map(([k, v]) => [k, v.schema])));
+export function registerTestConfigOptions(command) {
+    for (const field of Object.values(testConfigFields)) {
+        const cli = field.cli;
+        if (cli.parseArg) {
+            command.option(cli.flags, cli.description, cli.parseArg);
+        }
+        else {
+            command.option(cli.flags, cli.description);
+        }
+        if (cli.negatable) {
+            const flagName = cli.flags.split(" ")[0].replace("--", "");
+            command.option(`--no-${flagName}`, `Disable ${cli.description.toLowerCase().replace(/\.$/, "")}`);
+        }
+    }
+}
+function snakeToCamel(str) {
+    return str.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+export function parseCliTestOptions(opts) {
+    const result = {};
+    for (const snake of Object.keys(testConfigFields)) {
+        const camel = snakeToCamel(snake);
+        let value = opts[camel];
+        if (value !== undefined) {
+            if (snake === "bail" && value === true) {
+                value = 1;
+            }
+            result[snake] = value;
+        }
+    }
+    return result;
+}

package/config.test.js

@@ -0,0 +1,94 @@
+import { describe, it, expect, beforeEach, afterEach, assertType } from "vitest";
+import * as fs from "fs";
+import * as path from "path";
+import { loadConfig, mergeTestConfig, buildTestConfig } from "./config/index.js";
+const testDir = path.join(import.meta.dirname, "__test_fixtures__");
+describe("loadConfig", () => {
+    beforeEach(() => {
+        fs.mkdirSync(testDir, { recursive: true });
+    });
+    afterEach(() => {
+        fs.rmSync(testDir, { recursive: true, force: true });
+    });
+    it("returns empty object when no config exists", () => {
+        expect(loadConfig(path.join(testDir, "nonexistent.json"))).toEqual({});
+    });
+    it("loads factorio-test.json with snake_case test config", () => {
+        const configPath = path.join(testDir, "factorio-test.json");
+        fs.writeFileSync(configPath, JSON.stringify({
+            modPath: "./test",
+            test: { game_speed: 100 },
+        }));
+        expect(loadConfig(configPath)).toMatchObject({
+            modPath: path.join(testDir, "test"),
+            test: { game_speed: 100 },
+        });
+    });
+    it("throws on invalid keys", () => {
+        const configPath = path.join(testDir, "bad.json");
+        fs.writeFileSync(configPath, JSON.stringify({ test: { invalid_key: true } }));
+        expect(() => loadConfig(configPath)).toThrow();
+    });
+    it("error message includes file path for invalid top-level key", () => {
+        const configPath = path.join(testDir, "bad-toplevel.json");
+        fs.writeFileSync(configPath, JSON.stringify({ unknownKey: true }));
+        expect(() => loadConfig(configPath)).toThrow(configPath);
+    });
+    it("error message includes field name for invalid top-level key", () => {
+        const configPath = path.join(testDir, "bad-toplevel.json");
+        fs.writeFileSync(configPath, JSON.stringify({ unknownKey: true }));
+        expect(() => loadConfig(configPath)).toThrow(/unknownKey/);
+    });
+    it("error message includes field path for invalid nested key", () => {
+        const configPath = path.join(testDir, "bad-nested.json");
+        fs.writeFileSync(configPath, JSON.stringify({ test: { badNestedKey: true } }));
+        expect(() => loadConfig(configPath)).toThrow(/test/);
+    });
+    it("error message includes field name for type mismatch", () => {
+        const configPath = path.join(testDir, "bad-type.json");
+        fs.writeFileSync(configPath, JSON.stringify({ test: { game_speed: "fast" } }));
+        expect(() => loadConfig(configPath)).toThrow(/game_speed/);
+    });
+});
+describe("TestRunnerConfig type compatibility", () => {
+    it("all TestRunnerConfig keys exist in FactorioTest.Config with compatible types", () => {
+        assertType({});
+    });
+});
+describe("mergeTestConfig", () => {
+    it("CLI options override config file", () => {
+        const result = mergeTestConfig({ game_speed: 100 }, { game_speed: 200 });
+        expect(result.game_speed).toBe(200);
+    });
+    it("CLI test pattern overrides config file", () => {
+        const result = mergeTestConfig({ test_pattern: "foo" }, { test_pattern: "bar" });
+        expect(result.test_pattern).toBe("bar");
+    });
+    it("preserves config file values when CLI undefined", () => {
+        const result = mergeTestConfig({ game_speed: 100, log_passed_tests: true }, {});
+        expect(result.game_speed).toBe(100);
+        expect(result.log_passed_tests).toBe(true);
+    });
+});
+describe("buildTestConfig test pattern priority", () => {
+    const baseOptions = { dataDirectory: "." };
+    it("positional patterns override CLI option and config file", () => {
+        const result = buildTestConfig({ test: { test_pattern: "config" } }, { ...baseOptions, testPattern: "cli" }, [
+            "pos1",
+            "pos2",
+        ]);
+        expect(result.test_pattern).toBe("(pos1)|(pos2)");
+    });
+    it("CLI option overrides config file when no positional patterns", () => {
+        const result = buildTestConfig({ test: { test_pattern: "config" } }, { ...baseOptions, testPattern: "cli" }, []);
+        expect(result.test_pattern).toBe("cli");
+    });
+    it("uses config file when no CLI option or positional patterns", () => {
+        const result = buildTestConfig({ test: { test_pattern: "config" } }, baseOptions, []);
+        expect(result.test_pattern).toBe("config");
+    });
+    it("undefined when no patterns specified anywhere", () => {
+        const result = buildTestConfig({}, baseOptions, []);
+        expect(result.test_pattern).toBeUndefined();
+    });
+});

package/factorio-discovery.js

@@ -0,0 +1,53 @@
+import * as os from "os";
+import * as fs from "fs";
+import * as path from "path";
+import { spawnSync } from "child_process";
+import { CliError } from "./cli-error.js";
+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");
+}

package/factorio-discovery.test.js

@@ -0,0 +1,24 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+vi.mock("child_process", () => ({
+    spawnSync: vi.fn(() => ({ status: 1 })),
+}));
+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-discovery.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-discovery.js");
+        expect(() => autoDetectFactorioPath()).toThrow(/Could not auto-detect/);
+    });
+});

package/factorio-output-parser.js

@@ -0,0 +1,41 @@
+import { EventEmitter } from "events";
+const EVENT_PREFIX = "FACTORIO-TEST-EVENT:";
+export function parseEvent(line) {
+    if (!line.startsWith(EVENT_PREFIX)) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(line.slice(EVENT_PREFIX.length));
+    }
+    catch {
+        return undefined;
+    }
+}
+export class FactorioOutputHandler extends EventEmitter {
+    inMessage = false;
+    handleLine(line) {
+        if (line.startsWith("FACTORIO-TEST-RESULT:")) {
+            this.emit("result", line.slice("FACTORIO-TEST-RESULT:".length));
+            return;
+        }
+        if (line === "FACTORIO-TEST-MESSAGE-START") {
+            this.inMessage = true;
+            return;
+        }
+        if (line === "FACTORIO-TEST-MESSAGE-END") {
+            this.inMessage = false;
+            return;
+        }
+        const event = parseEvent(line);
+        if (event) {
+            this.emit("event", event);
+            return;
+        }
+        if (this.inMessage) {
+            this.emit("message", line);
+        }
+        else {
+            this.emit("log", line);
+        }
+    }
+}

package/factorio-output-parser.test.js

@@ -0,0 +1,38 @@
+import { describe, it, expect } from "vitest";
+import { parseEvent } from "./factorio-output-parser.js";
+describe("parseEvent", () => {
+    it("parses valid testStarted event", () => {
+        const line = 'FACTORIO-TEST-EVENT:{"type":"testStarted","test":{"path":"root > mytest"}}';
+        const result = parseEvent(line);
+        expect(result).toEqual({
+            type: "testStarted",
+            test: { path: "root > mytest" },
+        });
+    });
+    it("parses valid testPassed event with duration", () => {
+        const line = 'FACTORIO-TEST-EVENT:{"type":"testPassed","test":{"path":"root > test","duration":"1.23 ms"}}';
+        const result = parseEvent(line);
+        expect(result).toEqual({
+            type: "testPassed",
+            test: { path: "root > test", duration: "1.23 ms" },
+        });
+    });
+    it("parses testFailed event with errors", () => {
+        const line = 'FACTORIO-TEST-EVENT:{"type":"testFailed","test":{"path":"test"},"errors":["error1","error2"]}';
+        const result = parseEvent(line);
+        expect(result).toEqual({
+            type: "testFailed",
+            test: { path: "test" },
+            errors: ["error1", "error2"],
+        });
+    });
+    it("returns undefined for non-event lines", () => {
+        expect(parseEvent("some random log line")).toBeUndefined();
+        expect(parseEvent("FACTORIO-TEST-MESSAGE-START")).toBeUndefined();
+        expect(parseEvent("")).toBeUndefined();
+    });
+    it("returns undefined for malformed JSON", () => {
+        expect(parseEvent("FACTORIO-TEST-EVENT:{not valid json}")).toBeUndefined();
+        expect(parseEvent("FACTORIO-TEST-EVENT:")).toBeUndefined();
+    });
+});