factorio-test-cli 2.0.0 → 3.0.0

package/run.js

@@ -1,293 +1,216 @@
 import { program } from "commander";
-import * as os from "os";
 import * as fsp from "fs/promises";
-import * as fs from "fs";
 import * as path from "path";
-import { spawn, spawnSync } from "child_process";
-import BufferLineSplitter from "./buffer-line-splitter.js";
+import * as dgram from "dgram";
 import chalk from "chalk";
-import * as process from "node:process";
+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 { watchDirectory, watchFile } from "./file-watcher.js";
 const thisCommand = program
     .command("run")
     .summary("Runs tests with Factorio test.")
-    .description("Runs tests for the specified mod with Factorio test. Exits with code 0 only if all tests pass.\n")
-    .argument("[mod-path]", "The path to the mod (folder containing info.json). A symlink will be created in the mods folder to this folder. Either this or --mod-name must be specified.")
-    .option("--mod-name <name>", "The name of the mod to test. To use this option, the mod must already be present in the mods directory (see --data-directory). Either this or [mod-path] must be specified.")
-    .option("--factorio-path <path>", "The path to the factorio binary. If not specified, attempts to auto-detect the path.")
-    .option("-d --data-directory <path>", 'The path to the factorio data directory that the testing instance will use. The "config.ini" file and the "mods" folder will be in this directory.', "./factorio-test-data-dir")
-    .option("--mods <mods...>", 'Adjust mods. By default, only the mod to test and "factorio-test" are enabled, and all others are disabled! ' +
-    'Same format as "fmtk mods adjust". Example: "--mods mod1 mod2=1.2.3" will enable mod1 any version, and mod2 version 1.2.3.')
-    .option("--show-output", "Print test output to stdout.", true)
-    .option("-v --verbose", "Enables more logging, and pipes the Factorio process output to stdout.")
-    .addHelpText("after", 'Arguments after "--" are passed to the Factorio process.')
-    .addHelpText("after", 'Suggested factorio arguments: "--cache-sprite-atlas", "--disable-audio"')
-    .action((modPath, options) => runTests(modPath, options));
-async function runTests(modPath, options) {
-    if (modPath !== undefined && options.modName !== undefined) {
-        throw new Error("Only one of --mod-path or --mod-name can be specified.");
-    }
-    if (modPath === undefined && options.modName === undefined) {
-        throw new Error("One of --mod-path or --mod-name must be specified.");
+    .description(`Runs tests for the specified mod with Factorio test. Exits with code 0 only if all tests pass.
+
+One of --mod-path or --mod-name is required.
+Test execution options (--test-pattern, --tag-*, --bail, etc.) override in-mod config.
+
+When using variadic options (--mods, --factorio-args, etc.) with filter patterns,
+use -- to separate them:
+  factorio-test run -p ./my-mod --mods quality space-age -- "inventory"
+
+Examples:
+  factorio-test run -p ./my-mod             Run all tests
+  factorio-test run -p ./my-mod -v          Run with verbose output
+  factorio-test run -p ./my-mod -gw         Run with graphics in watch mode
+  factorio-test run -p ./my-mod -b          Bail on first failure
+  factorio-test run -p ./my-mod "inventory" Run tests matching "inventory"
+`)
+    .argument("[filter...]", "Test patterns to filter (OR logic)");
+registerAllCliOptions(thisCommand);
+thisCommand.action((patterns, options) => {
+    runTests(patterns, options);
+});
+async function setupTestRun(patterns, options) {
+    const fileConfig = loadConfig(options.config);
+    mergeCliConfig(fileConfig, options);
+    setVerbose(!!options.verbose);
+    if (options.modPath !== undefined && options.modName !== undefined) {
+        throw new CliError("Only one of --mod-path or --mod-name can be specified.");
+    }
+    if (options.modPath === undefined && options.modName === undefined) {
+        throw new CliError("One of --mod-path or --mod-name must be specified.");
     }
     const factorioPath = options.factorioPath ?? autoDetectFactorioPath();
     const dataDir = path.resolve(options.dataDirectory);
     const modsDir = path.join(dataDir, "mods");
     await fsp.mkdir(modsDir, { recursive: true });
-    const modToTest = await configureModToTest(modsDir, modPath, options.modName);
+    const modToTest = await configureModToTest(modsDir, options.modPath, options.modName, options.verbose);
+    const modDependencies = options.modPath
+        ? await installModDependencies(modsDir, path.resolve(options.modPath), options.verbose)
+        : [];
     await installFactorioTest(modsDir);
     const enableModsOptions = [
         "factorio-test=true",
         `${modToTest}=true`,
+        ...modDependencies.map((m) => `${m}=true`),
         ...(options.mods?.map((m) => (m.includes("=") ? m : `${m}=true`)) ?? []),
     ];
     if (options.verbose)
         console.log("Adjusting mods");
-    await runScript("fmtk mods adjust", "--modsPath", modsDir, "--disableExtra", ...enableModsOptions);
+    await runScript("fmtk", "mods", "adjust", "--modsPath", modsDir, "--disableExtra", ...enableModsOptions);
     await ensureConfigIni(dataDir);
-    await setSettingsForAutorun(factorioPath, dataDir, modsDir, modToTest);
-    let resultMessage;
-    try {
-        resultMessage = await runFactorioTests(factorioPath, dataDir);
-    }
-    finally {
-        if (options.verbose)
-            console.log("Disabling auto-start settings");
-        await runScript("fmtk settings set startup factorio-test-auto-start false", "--modsPath", modsDir);
-    }
-    if (resultMessage) {
-        const color = resultMessage == "passed" ? chalk.greenBright : resultMessage == "todo" ? chalk.yellowBright : chalk.redBright;
-        console.log("Test run result:", color(resultMessage));
-        process.exit(resultMessage === "passed" ? 0 : 1);
-    }
+    const mode = options.graphics ? "graphics" : "headless";
+    const savePath = getHeadlessSavePath(options.save ?? fileConfig.save);
+    const outputPath = options.outputFile === false
+        ? undefined
+        : (options.outputFile ?? fileConfig.outputFile ?? getDefaultOutputPath(dataDir));
+    const testConfig = buildTestConfig(fileConfig, options, patterns);
+    const udpPort = options.watch && options.graphics ? (options.udpPort ?? fileConfig.udpPort ?? 14434) : undefined;
+    const factorioArgs = [...(options.factorioArgs ?? [])];
+    if (udpPort !== undefined) {
+        factorioArgs.push(`--enable-lua-udp=${udpPort}`);
+    }
+    return {
+        factorioPath,
+        dataDir,
+        modsDir,
+        modToTest,
+        mode,
+        savePath,
+        outputPath,
+        factorioArgs,
+        testConfig,
+        options,
+        fileConfig,
+        udpPort,
+    };
 }
-async function configureModToTest(modsDir, modPath, modName) {
-    if (modPath) {
-        if (thisCommand.opts().verbose)
-            console.log("Creating mod symlink", modPath);
-        return configureModPath(modPath, modsDir);
-    }
-    else {
-        await configureModName(modsDir, modName);
-        return modName;
+async function executeTestRun(ctx, execOptions) {
+    const { factorioPath, dataDir, modsDir, modToTest, mode, savePath, outputPath, factorioArgs, testConfig, options } = ctx;
+    const { signal, skipResetAutorun, resolveOnResult } = execOptions ?? {};
+    const reorderEnabled = options.reorderFailedFirst ?? ctx.fileConfig.test?.reorder_failed_first ?? true;
+    const lastFailedTests = reorderEnabled && outputPath ? await readPreviousFailedTests(outputPath) : [];
+    await setSettingsForAutorun(factorioPath, dataDir, modsDir, modToTest, mode, {
+        verbose: options.verbose,
+        lastFailedTests,
+    });
+    if (Object.keys(testConfig).length > 0) {
+        await runScript("fmtk", "settings", "set", "runtime-global", "factorio-test-config", JSON.stringify(testConfig), "--modsPath", modsDir);
     }
-}
-async function configureModPath(modPath, modsDir) {
-    modPath = path.resolve(modPath);
-    const infoJsonFile = path.join(modPath, "info.json");
-    let infoJson;
+    let result;
     try {
-        infoJson = JSON.parse(await fsp.readFile(infoJsonFile, "utf8"));
+        result =
+            mode === "headless"
+                ? await runFactorioTestsHeadless(factorioPath, dataDir, savePath, factorioArgs, {
+                    verbose: options.verbose,
+                    quiet: options.quiet,
+                    signal,
+                })
+                : await runFactorioTestsGraphics(factorioPath, dataDir, savePath, factorioArgs, {
+                    verbose: options.verbose,
+                    quiet: options.quiet,
+                    resolveOnResult,
+                });
     }
-    catch (e) {
-        throw new Error(`Could not read info.json file from ${modPath}`, { cause: e });
-    }
-    const modName = infoJson.name;
-    if (typeof modName !== "string") {
-        throw new Error(`info.json file at ${infoJsonFile} does not contain a string property "name".`);
-    }
-    // make symlink modsDir/modName -> modPath
-    // delete if exists
-    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) {
-    // check if modName is in modsDir
-    const alreadyExists = await checkModExists(modsDir, modName);
-    if (!alreadyExists) {
-        throw new Error(`Mod ${modName} not found in ${modsDir}.`);
+    finally {
+        if (!skipResetAutorun) {
+            await resetAutorunSettings(modsDir, options.verbose);
+            await runScript("fmtk", "settings", "set", "runtime-global", "factorio-test-config", "{}", "--modsPath", modsDir);
+        }
     }
-    return modName;
-}
-async function checkModExists(modsDir, modName) {
-    const alreadyExists = (await fsp.stat(modsDir).catch(() => undefined))?.isDirectory() &&
-        (await fsp.readdir(modsDir))?.find((f) => {
-            const stat = fs.statSync(path.join(modsDir, f), { throwIfNoEntry: false });
-            if (stat?.isDirectory()) {
-                return f === modName || f.match(new RegExp(`^${modName}_\\d+\\.\\d+\\.\\d+$`));
-            }
-            if (stat?.isFile()) {
-                return f === modName + ".zip" || f.match(new RegExp(`^${modName}_\\d+\\.\\d+\\.\\d+\\.zip$`));
-            }
-        });
-    return !!alreadyExists;
-}
-async function installFactorioTest(modsDir) {
-    await fsp.mkdir(modsDir, { recursive: true });
-    const testModName = "factorio-test";
-    // if not found, install it
-    const alreadyExists = await checkModExists(modsDir, testModName);
-    if (!alreadyExists) {
-        console.log(`Downloading ${testModName} from mod portal using fmtk. This may ask for factorio login credentials.`);
-        await runScript("fmtk mods install", "--modsPath", modsDir, testModName);
+    if (result.status === "cancelled") {
+        return { exitCode: 0, status: "cancelled" };
     }
-}
-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=
-`);
+    if (outputPath && result.data) {
+        await writeResultsFile(outputPath, modToTest, result.data);
+        if (options.verbose)
+            console.log(`Results written to ${outputPath}`);
     }
-    else {
-        // edit "^write-data=.*" to be dataDir
-        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);
-        }
+    let resultStatus = result.status;
+    if (resultStatus === "bailed") {
+        console.log(chalk.yellow(`Bailed out after ${testConfig.bail} failure(s)`));
+        resultStatus = "failed";
     }
-}
-async function setSettingsForAutorun(factorioPath, dataDir, modsDir, modToTest) {
-    // touch modsDir/mod-settings.dat
-    const settingsDat = path.join(modsDir, "mod-settings.dat");
-    if (!fs.existsSync(settingsDat)) {
-        if (thisCommand.opts().verbose)
-            console.log("Creating mod-settings.dat file by running factorio");
-        // run factorio once to create it
-        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);
-        }
+    const color = resultStatus == "passed" ? chalk.greenBright : resultStatus == "todo" ? chalk.yellowBright : chalk.redBright;
+    console.log("Test run result:", color(resultStatus));
+    const forbidOnly = options.forbidOnly ?? ctx.fileConfig.forbidOnly ?? true;
+    if (result.hasFocusedTests && forbidOnly) {
+        console.log(chalk.redBright("Error: .only tests are present but --forbid-only is enabled"));
+        return { exitCode: 1, status: resultStatus };
     }
-    if (thisCommand.opts().verbose)
-        console.log("Setting autorun settings");
-    await runScript("fmtk settings set startup factorio-test-auto-start true", "--modsPath", modsDir);
-    await runScript("fmtk settings set runtime-global factorio-test-mod-to-test", modToTest, "--modsPath", modsDir);
+    return { exitCode: resultStatus === "passed" ? 0 : 1, status: resultStatus };
 }
-async function runFactorioTests(factorioPath, dataDir) {
-    const args = process.argv;
-    const index = args.indexOf("--");
-    const additionalArgs = index >= 0 ? args.slice(index + 1) : [];
-    const actualArgs = [
-        "--load-scenario",
-        "factorio-test/Test",
-        "--disable-migration-window",
-        "--mod-directory",
-        path.join(dataDir, "mods"),
-        "-c",
-        path.join(dataDir, "config.ini"),
-        "--graphics-quality",
-        "low",
-        ...additionalArgs,
-    ];
-    console.log("Running tests...");
-    const factorioProcess = spawn(factorioPath, actualArgs, {
-        stdio: ["inherit", "pipe", "inherit"],
-    });
-    const verbose = thisCommand.opts().verbose;
-    const showOutput = thisCommand.opts().showOutput;
-    let resultMessage = undefined;
-    let isMessage = false;
-    let isMessageFirstLine = true;
-    new BufferLineSplitter(factorioProcess.stdout).on("line", (line) => {
-        if (line.startsWith("FACTORIO-TEST-RESULT:")) {
-            resultMessage = line.slice("FACTORIO-TEST-RESULT:".length);
-            factorioProcess.kill();
-        }
-        else if (line === "FACTORIO-TEST-MESSAGE-START") {
-            isMessage = true;
-            isMessageFirstLine = true;
-        }
-        else if (line === "FACTORIO-TEST-MESSAGE-END") {
-            isMessage = false;
-        }
-        else if (verbose) {
-            console.log(line);
-        }
-        else if (isMessage && showOutput) {
-            if (isMessageFirstLine) {
-                console.log(line.slice(line.indexOf(": ") + 2));
-                isMessageFirstLine = false;
-            }
-            else {
-                // print line with tab
-                console.log("    " + line);
-            }
-        }
-    });
-    await new Promise((resolve, reject) => {
-        factorioProcess.on("exit", (code, signal) => {
-            if (code === 0 && resultMessage !== undefined) {
-                resolve();
+const DEFAULT_WATCH_PATTERNS = ["info.json", "**/*.lua"];
+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(() => { });
+    }
+    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();
             }
-            else {
-                reject(new Error(`Factorio exited with code ${code}, signal ${signal}`));
+            abortController = new AbortController();
+            isRunning = true;
+            console.log("\n" + "─".repeat(60));
+            try {
+                await executeTestRun(ctx, { signal: abortController.signal });
             }
-        });
-    });
-    return resultMessage;
-}
-function runScript(...command) {
-    return runProcess(true, "npx", ...command);
-}
-function runProcess(inheritStdio, command, ...args) {
-    if (thisCommand.opts().verbose)
-        console.log("Running:", command, ...args);
-    // run another npx command
-    const process = spawn(command, args, {
-        stdio: inheritStdio ? "inherit" : "ignore",
-        shell: true,
-    });
-    return new Promise((resolve, reject) => {
-        process.on("error", reject);
-        process.on("exit", (code) => {
-            if (code === 0) {
-                resolve();
+            catch (e) {
+                if (e instanceof CliError) {
+                    console.error(chalk.red(e.message));
+                }
+                else {
+                    throw e;
+                }
             }
-            else {
-                reject(new Error(`Command exited with code ${code}: ${command} ${args.join(" ")}`));
+            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);
         });
-    });
-}
-function factorioIsInPath() {
-    const result = spawnSync("factorio", ["--version"], { stdio: "ignore" });
-    return result.status === 0;
-}
-function autoDetectFactorioPath() {
-    if (factorioIsInPath()) {
-        return "factorio";
-    }
-    let pathsToTry;
-    // check if is linux
-    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",
-        ];
+        await new Promise(() => { });
     }
     else {
-        throw new Error(`Can not 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);
-        }
+        const result = await executeTestRun(ctx);
+        process.exit(result.exitCode);
     }
-    throw new Error(`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/schema.test.js

@@ -0,0 +1,67 @@
+import { describe, it, expect } from "vitest";
+import { testRunnerConfigSchema, cliConfigSchema, parseCliTestOptions } from "./config/index.js";
+describe("testRunnerConfigSchema", () => {
+    it("parses valid config with snake_case keys", () => {
+        const config = {
+            test_pattern: "foo",
+            game_speed: 100,
+            log_passed_tests: true,
+        };
+        expect(testRunnerConfigSchema.parse(config)).toEqual(config);
+    });
+    it("rejects invalid types", () => {
+        expect(() => testRunnerConfigSchema.parse({ game_speed: "fast" })).toThrow();
+    });
+    it("allows empty config", () => {
+        expect(testRunnerConfigSchema.parse({})).toEqual({});
+    });
+    it("rejects unknown keys", () => {
+        expect(() => testRunnerConfigSchema.parse({ unknown_key: true })).toThrow();
+    });
+});
+describe("cliConfigSchema", () => {
+    it("parses config file with snake_case test keys", () => {
+        const config = {
+            modPath: "./my-mod",
+            test: { game_speed: 50, log_passed_tests: true },
+        };
+        expect(cliConfigSchema.parse(config)).toEqual(config);
+    });
+    it("rejects unknown keys in strict mode", () => {
+        expect(() => cliConfigSchema.strict().parse({ unknownKey: true })).toThrow();
+    });
+    it("accepts forbidOnly boolean", () => {
+        const config = { forbidOnly: false };
+        expect(cliConfigSchema.parse(config)).toEqual(config);
+    });
+    it("defaults forbidOnly to undefined", () => {
+        expect(cliConfigSchema.parse({}).forbidOnly).toBeUndefined();
+    });
+});
+describe("parseCliTestOptions", () => {
+    it("converts Commander camelCase output to snake_case", () => {
+        const commanderOpts = {
+            testPattern: "foo",
+            gameSpeed: 100,
+            logPassedTests: true,
+        };
+        expect(parseCliTestOptions(commanderOpts)).toEqual({
+            test_pattern: "foo",
+            game_speed: 100,
+            log_passed_tests: true,
+        });
+    });
+    it("omits undefined values", () => {
+        expect(parseCliTestOptions({ gameSpeed: 100 })).toEqual({ game_speed: 100 });
+    });
+    it("returns empty object for empty input", () => {
+        expect(parseCliTestOptions({})).toEqual({});
+    });
+    it("passes through bail option", () => {
+        expect(parseCliTestOptions({ bail: 1 })).toEqual({ bail: 1 });
+        expect(parseCliTestOptions({ bail: 3 })).toEqual({ bail: 3 });
+    });
+    it("converts bail=true to bail=1 (commander behavior for --bail without value)", () => {
+        expect(parseCliTestOptions({ bail: true })).toEqual({ bail: 1 });
+    });
+});

package/test-run-collector.js

@@ -0,0 +1,92 @@
+import { EventEmitter } from "events";
+export class TestRunCollector extends EventEmitter {
+    data = { tests: [] };
+    currentTest;
+    currentLogs = [];
+    testStartTime;
+    handleEvent(event) {
+        switch (event.type) {
+            case "testStarted":
+                this.flushCurrentTest();
+                this.testStartTime = performance.now();
+                this.currentTest = {
+                    path: event.test.path,
+                    source: event.test.source,
+                    result: "passed",
+                    errors: [],
+                    logs: [],
+                };
+                this.currentLogs = [];
+                break;
+            case "testPassed":
+                if (this.currentTest) {
+                    this.currentTest.result = "passed";
+                    if (this.testStartTime !== undefined) {
+                        this.currentTest.durationMs = performance.now() - this.testStartTime;
+                    }
+                    this.currentTest.logs = [...this.currentLogs];
+                }
+                this.flushCurrentTest();
+                break;
+            case "testFailed":
+                if (this.currentTest) {
+                    this.currentTest.result = "failed";
+                    this.currentTest.errors = event.errors;
+                    if (this.testStartTime !== undefined) {
+                        this.currentTest.durationMs = performance.now() - this.testStartTime;
+                    }
+                    this.currentTest.logs = [...this.currentLogs];
+                }
+                this.flushCurrentTest();
+                break;
+            case "testSkipped":
+                this.flushCurrentTest();
+                this.finishTest({
+                    path: event.test.path,
+                    source: event.test.source,
+                    result: "skipped",
+                    errors: [],
+                    logs: [],
+                });
+                break;
+            case "testTodo":
+                this.flushCurrentTest();
+                this.finishTest({
+                    path: event.test.path,
+                    source: event.test.source,
+                    result: "todo",
+                    errors: [],
+                    logs: [],
+                });
+                break;
+            case "testRunFinished":
+                this.flushCurrentTest();
+                this.data.summary = event.results;
+                this.emit("runFinished", this.data);
+                break;
+            case "testRunCancelled":
+                this.flushCurrentTest();
+                break;
+        }
+    }
+    captureLog(line) {
+        if (this.currentTest) {
+            this.currentLogs.push(line);
+        }
+    }
+    getData() {
+        return this.data;
+    }
+    flushCurrentTest() {
+        if (this.currentTest) {
+            this.finishTest(this.currentTest);
+            this.currentTest = undefined;
+            this.currentLogs = [];
+            this.testStartTime = undefined;
+        }
+    }
+    finishTest(test) {
+        this.data.tests.push(test);
+        this.emit("testFinished", test);
+    }
+}