factorio-test-cli 3.3.1 → 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) => {

package/package.json

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

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