factorio-test-cli 3.3.0 → 3.4.0

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) => {
@@ -132,6 +132,9 @@ function createOutputComponents(options) {
         progress.handleTestFinished(test);
         progress.withPermanentOutput(() => printer.printTestResult(test));
     });
+    collector.on("describeBlockFailed", (block) => {
+        progress.withPermanentOutput(() => printer.printTestResult(block));
+    });
     handler.on("result", () => {
         progress.finish();
         printer.resetMessage();

package/package.json

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

package/test-output.js

@@ -87,16 +87,19 @@ export class OutputFormatter {
     formatTestResult(test) {
         if (this.options.quiet)
             return;
-        const showLogs = test.result === "failed" || this.options.showPassedLogs;
+        const prefix = this.getPrefix(test.result);
+        const duration = test.durationMs !== undefined ? ` (${formatDuration(test.durationMs)})` : "";
+        console.log(`${prefix} ${test.path}${duration}`);
+        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) {
                 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") {
+        if ((test.result === "failed" || test.result === "error") && test.errors.length > 0) {
+            console.log("Errors:");
             for (const error of test.errors) {
                 console.log("    " + error);
             }
@@ -107,6 +110,7 @@ export class OutputFormatter {
             return;
         if (!this.options.quiet) {
             this.printRecapSection(data.tests, "failed", "Failures:");
+            this.printRecapSection(data.tests, "error", "Describe block errors:");
             this.printRecapSection(data.tests, "todo", "Todo:");
         }
         this.printCountsLine(data.summary);
@@ -126,6 +130,8 @@ export class OutputFormatter {
         const segments = [];
         if (summary.failed > 0)
             segments.push(chalk.red(`${summary.failed} failed`));
+        if (summary.describeBlockErrors > 0)
+            segments.push(chalk.red(`${summary.describeBlockErrors} errors`));
         if (summary.todo > 0)
             segments.push(chalk.magenta(`${summary.todo} todo`));
         if (summary.skipped > 0)
@@ -134,12 +140,28 @@ 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":
                 return chalk.green("PASS");
             case "failed":
                 return chalk.red("FAIL");
+            case "error":
+                return chalk.red("ERROR");
             case "skipped":
                 return chalk.yellow("SKIP");
             case "todo":
@@ -157,6 +179,7 @@ export class OutputPrinter {
             verbose: options.verbose,
             quiet: options.quiet,
             showPassedLogs: options.verbose,
+            showLogs: !options.verbose,
         });
     }
     printTestResult(test) {
@@ -180,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

@@ -150,12 +150,19 @@ describe("OutputFormatter", () => {
         expect(output.some((line) => line.includes("assertion failed"))).toBe(true);
         expect(output.some((line) => line.includes("at test.ts:10"))).toBe(true);
     });
-    it("shows logs before failed test result", () => {
+    it("shows status line first, then logs and errors with headers", () => {
         const formatter = new OutputFormatter({});
         formatter.formatTestResult(failedTest);
-        const logIndex = output.findIndex((line) => line.includes("debug output"));
         const failIndex = output.findIndex((line) => line.includes("FAIL"));
-        expect(logIndex).toBeLessThan(failIndex);
+        const logHeaderIndex = output.findIndex((line) => line.includes("Log messages:"));
+        const logIndex = output.findIndex((line) => line.includes("debug output"));
+        const errorHeaderIndex = output.findIndex((line) => line.includes("Errors:"));
+        const errorIndex = output.findIndex((line) => line.includes("assertion failed"));
+        expect(failIndex).toBe(0);
+        expect(logHeaderIndex).toBeGreaterThan(failIndex);
+        expect(logIndex).toBeGreaterThan(logHeaderIndex);
+        expect(errorHeaderIndex).toBeGreaterThan(logIndex);
+        expect(errorIndex).toBeGreaterThan(errorHeaderIndex);
     });
     it("hides logs for passed tests by default", () => {
         const formatter = new OutputFormatter({});
@@ -199,6 +206,120 @@ describe("OutputFormatter", () => {
         expect(output[0]).toContain("TODO");
         expect(output[0]).toContain("todo test");
     });
+    it("formats describe block error with ERROR prefix", () => {
+        const formatter = new OutputFormatter({});
+        const errorTest = {
+            path: "root > block",
+            result: "error",
+            errors: ["Error running afterAll: Oh no"],
+            logs: ["hook log"],
+        };
+        formatter.formatTestResult(errorTest);
+        expect(output[0]).toContain("ERROR");
+        expect(output[0]).toContain("root > block");
+        expect(output.some((line) => line.includes("Log messages:"))).toBe(true);
+        expect(output.some((line) => line.includes("hook log"))).toBe(true);
+        expect(output.some((line) => line.includes("Errors:"))).toBe(true);
+        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;
@@ -298,6 +419,37 @@ describe("OutputFormatter.formatSummary", () => {
         expect(countsLine).toContain("1 passed");
         expect(countsLine).toContain("(4 total)");
     });
+    it("shows describe block errors in separate section from failures", () => {
+        const formatter = new OutputFormatter({});
+        const data = {
+            tests: [
+                { path: "test", result: "failed", errors: ["test err"], logs: [] },
+                { path: "block", result: "error", errors: ["block err"], logs: [] },
+            ],
+            summary: makeSummary({ ran: 1, failed: 1, describeBlockErrors: 1, status: "failed" }),
+        };
+        formatter.formatSummary(data);
+        expect(output.some((l) => l.includes("Failures:"))).toBe(true);
+        expect(output.some((l) => l.includes("Describe block errors:"))).toBe(true);
+        const failuresIdx = output.findIndex((l) => l.includes("Failures:"));
+        const errorsIdx = output.findIndex((l) => l.includes("Describe block errors:"));
+        const failLine = output.findIndex((l) => l.includes("FAIL"));
+        const errorLine = output.findIndex((l) => l.includes("ERROR"));
+        expect(failLine).toBeGreaterThan(failuresIdx);
+        expect(failLine).toBeLessThan(errorsIdx);
+        expect(errorLine).toBeGreaterThan(errorsIdx);
+    });
+    it("includes describe block errors count in summary line", () => {
+        const formatter = new OutputFormatter({});
+        const data = {
+            tests: [{ path: "block", result: "error", errors: ["err"], logs: [] }],
+            summary: makeSummary({ passed: 1, describeBlockErrors: 2, status: "failed" }),
+        };
+        formatter.formatSummary(data);
+        const countsLine = output.find((l) => l.includes("Tests:"));
+        expect(countsLine).toContain("2 errors");
+        expect(countsLine).toContain("1 passed");
+    });
     it("does nothing when summary is undefined", () => {
         const formatter = new OutputFormatter({});
         formatter.formatSummary({ tests: [] });
@@ -349,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);

package/test-results.js

@@ -5,11 +5,13 @@ export class TestRunCollector extends EventEmitter {
     data = { tests: [] };
     currentTest;
     currentLogs = [];
+    pendingLogs = [];
     testStartTime;
     handleEvent(event) {
         switch (event.type) {
             case "testStarted":
                 this.flushCurrentTest();
+                this.pendingLogs = [];
                 this.testStartTime = performance.now();
                 this.currentTest = {
                     path: event.test.path,
@@ -61,6 +63,20 @@ export class TestRunCollector extends EventEmitter {
                     logs: [],
                 });
                 break;
+            case "describeBlockFailed": {
+                this.flushCurrentTest();
+                const captured = {
+                    path: event.block.path,
+                    source: event.block.source,
+                    result: "error",
+                    errors: event.errors,
+                    logs: [...this.pendingLogs],
+                };
+                this.data.tests.push(captured);
+                this.emit("describeBlockFailed", captured);
+                this.pendingLogs = [];
+                break;
+            }
             case "testRunFinished":
                 this.flushCurrentTest();
                 this.data.summary = event.results;
@@ -75,6 +91,9 @@ export class TestRunCollector extends EventEmitter {
         if (this.currentTest) {
             this.currentLogs.push(line);
         }
+        else {
+            this.pendingLogs.push(line);
+        }
     }
     getData() {
         return this.data;

package/test-results.test.js

@@ -38,12 +38,69 @@ describe("TestRunCollector", () => {
         const data = collector.getData();
         expect(data.tests[0].logs).toEqual(["log line 1", "log line 2"]);
     });
-    it("does not capture logs when no test is running", () => {
+    it("does not attach pending logs to skipped tests", () => {
         collector.captureLog("orphan log");
         collector.handleEvent({ type: "testSkipped", test: { path: "test" } });
         const data = collector.getData();
         expect(data.tests[0].logs).toEqual([]);
     });
+    it("handles describeBlockFailed with errors and pending logs", () => {
+        collector.captureLog("hook output");
+        collector.handleEvent({
+            type: "describeBlockFailed",
+            block: { path: "root > block", source: { file: "test.ts", line: 5 } },
+            errors: ["Error running afterAll: Oh no"],
+        });
+        const data = collector.getData();
+        expect(data.tests).toHaveLength(1);
+        expect(data.tests[0]).toMatchObject({
+            path: "root > block",
+            result: "error",
+            errors: ["Error running afterAll: Oh no"],
+            logs: ["hook output"],
+            source: { file: "test.ts", line: 5 },
+        });
+    });
+    it("emits describeBlockFailed event", () => {
+        const handler = vi.fn();
+        collector.on("describeBlockFailed", handler);
+        collector.handleEvent({
+            type: "describeBlockFailed",
+            block: { path: "block" },
+            errors: ["err"],
+        });
+        expect(handler).toHaveBeenCalledOnce();
+        expect(handler.mock.calls[0][0].path).toBe("block");
+    });
+    it("clears pending logs when a new test starts", () => {
+        collector.captureLog("before test");
+        collector.handleEvent({ type: "testStarted", test: { path: "test" } });
+        collector.handleEvent({ type: "testPassed", test: { path: "test" } });
+        collector.handleEvent({
+            type: "describeBlockFailed",
+            block: { path: "block" },
+            errors: ["err"],
+        });
+        const data = collector.getData();
+        const block = data.tests.find((t) => t.path === "block");
+        expect(block.logs).toEqual([]);
+    });
+    it("captures logs after test finishes for describe block failure", () => {
+        collector.handleEvent({ type: "testStarted", test: { path: "test" } });
+        collector.captureLog("test log");
+        collector.handleEvent({ type: "testPassed", test: { path: "test" } });
+        collector.captureLog("after_all log");
+        collector.handleEvent({
+            type: "describeBlockFailed",
+            block: { path: "block" },
+            errors: ["hook error"],
+        });
+        const data = collector.getData();
+        expect(data.tests[0].logs).toEqual(["test log"]);
+        const block = data.tests[1];
+        expect(block.logs).toEqual(["after_all log"]);
+        expect(block.errors).toEqual(["hook error"]);
+    });
     it("handles testSkipped without prior testStarted", () => {
         collector.handleEvent({ type: "testSkipped", test: { path: "skipped test" } });
         const data = collector.getData();