factorio-test-cli 3.3.0 → 3.3.1

package/factorio-process.js

@@ -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.3.1",
   "description": "A CLI to run FactorioTest.",
   "license": "MIT",
   "repository": {

package/test-output.js

@@ -87,16 +87,18 @@ 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 = 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 +109,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 +129,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)
@@ -140,6 +145,8 @@ export class OutputFormatter {
                 return chalk.green("PASS");
             case "failed":
                 return chalk.red("FAIL");
+            case "error":
+                return chalk.red("ERROR");
             case "skipped":
                 return chalk.yellow("SKIP");
             case "todo":

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,22 @@ 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.formatSummary", () => {
     let consoleSpy;
@@ -298,6 +321,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: [] });

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();