@matter/testing 0.12.2 → 0.12.3-alpha.0-20250205-ad3416ca3

package/src/mocha.ts

@@ -11,9 +11,11 @@ import { FailureDetail } from "./failure-detail.js";
 import { Boot } from "./mocks/boot.js";
 import { LoggerHooks } from "./mocks/logging.js";
 import { TestOptions } from "./options.js";
-import { ConsoleProxyReporter, Reporter } from "./reporter.js";
+import { Reporter } from "./reporter.js";
 import type { TestDescriptor } from "./test-descriptor.js";
+import { TextDiff } from "./text-diff.js";
 import { wtf } from "./util/wtf.js";
+import { WebReporter } from "./web-reporter.js";
 
 // We allow fixed 60s. timeout for our extended "before/after each test" hooks.  To make this configurable we'd need
 // to perform timeout handling ourselves so avoiding for now
@@ -92,7 +94,7 @@ export function generalSetup(mocha: Mocha) {
         return (this.currentTest as HookableTest)[afterOneHook]?.call(this, done);
     });
 
-    FailureDetail.diff = Base.generateDiff.bind(Base);
+    TextDiff.generator = Base.generateDiff.bind(Base);
 }
 
 export function extendApi(Mocha: typeof MochaType) {
@@ -262,7 +264,7 @@ export function browserSetup(mocha: BrowserMocha) {
         // Start Mocha, proxying reporting through console to Playwright and completing once Mocha has finished
         auto: async function (options: TestOptions) {
             TestOptions.apply(mocha, options);
-            mocha.reporter(adaptReporter(Mocha, "Web", new ConsoleProxyReporter()));
+            mocha.reporter(adaptReporter(Mocha, "Web", new WebReporter()));
             return new Promise<void>(accept => {
                 const runner = this.start();
                 runner.on("end", accept);

package/src/mocks/logging.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import colors from "ansi-colors";
+import { ansi, Wrapper } from "#tools/ansi-text";
 
 interface LoggerLike {
     format: string;
@@ -22,7 +22,7 @@ export const TheMockLogger: MockLogger = {
 };
 
 function formatExternalMessage(source: string, text: string) {
-    return `${colors.bgCyan.black.bold(` ${source} `)} ${colors.dim(text)}`;
+    return `${Wrapper.prefixStart}${ansi.black.bg.cyan.bold(` ${source} `)} ${Wrapper.prefixStop}${ansi.dim(text)}`;
 }
 
 /**

package/src/nodejs-reporter.ts

@@ -0,0 +1,123 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { Progress, ansi, std } from "#tools";
+import { FailureDetail } from "./failure-detail.js";
+import { FailureReporter } from "./failure-reporter.js";
+import { Failure, Reporter, Stats } from "./reporter.js";
+
+/**
+ * Test UI for Node.js.
+ */
+export abstract class NodejsReporter implements Reporter {
+    #run = "";
+    #suite = Array<string>();
+    #test?: string;
+    #step?: string;
+    #stats?: Stats;
+    #failures = Array<Failure>();
+    #lastTitle?: string;
+
+    constructor(private progress: Progress) {}
+
+    beginRun(name: string, stats: Stats | undefined, supportsSuites = true): void {
+        this.#run = name;
+        this.#suite = [];
+        this.#failures = [];
+        if (!supportsSuites) {
+            this.progress.update(this.#summarize(stats));
+        }
+    }
+
+    beginSuite(name: string[]): void {
+        this.#suite = name;
+    }
+
+    beginTest(name: string, stats?: Stats): void {
+        this.#test = name;
+        this.#stats = stats;
+        this.#step = undefined;
+
+        // If not a TTY, only update once per suite to keep the line count down for e.g. GH action logs
+        const title = process.stdout.isTTY ? this.#formatName(this.#suite, name) : this.#suite[0];
+        this.#updateTitle(title);
+    }
+
+    beginStep(name: string): void {
+        this.#step = name;
+
+        if (process.stdout.isTTY && this.#test) {
+            const title = this.#formatName(this.#suite, this.#test, name);
+            this.#updateTitle(title);
+        }
+    }
+
+    #updateTitle(title: string) {
+        if (title === this.#lastTitle) {
+            return;
+        }
+        this.#lastTitle = title;
+        this.progress.update(this.#summarize(this.#stats), title);
+    }
+
+    failTest(name: string, detail: FailureDetail) {
+        this.#failures.push({
+            suite: this.#suite,
+            test: name,
+            step: this.#step,
+            detail,
+        });
+    }
+
+    abstract failRun(detail: FailureDetail): void;
+
+    endRun(stats?: Stats): void {
+        if (this.#failures.length) {
+            this.progress.failure(this.#summarize(stats));
+            this.#dumpFailures();
+        } else if (stats && !stats.complete) {
+            this.progress.failure("No tests found");
+        } else {
+            this.progress.success(this.#summarize(stats));
+        }
+    }
+
+    #summarize(stats?: Stats) {
+        let statStr;
+        if (stats) {
+            const complete = ansi.dim(`${stats.complete}/${stats.total}`);
+            const failures = stats.failures ? ansi.bright.red(` ${stats.failures.toString()} failed`) : "";
+            statStr = ` ${complete}${failures}`;
+        } else {
+            statStr = "";
+        }
+
+        return `${ansi.bold(this.#run)}${statStr}`;
+    }
+
+    #dumpFailures() {
+        for (let i = 0; i < this.#failures.length; i++) {
+            if (i !== 0) {
+                std.out("\n");
+            }
+
+            const failure = this.#failures[i];
+            const index = `Failure ${ansi.bold((i + 1).toString())} of ${this.#failures.length}`;
+            const title = `${index} ${this.#formatName(failure.suite, failure.test, failure.step)}`;
+
+            FailureReporter.report(std.out, failure.detail, title);
+        }
+    }
+
+    #formatName(suite: string[], test: string, step?: string) {
+        const breadcrumb = [...suite, test];
+        if (step) {
+            breadcrumb.push(step);
+        }
+        breadcrumb[breadcrumb.length - 1] = ansi.bold(breadcrumb[breadcrumb.length - 1]).toString();
+        return breadcrumb.join(" ➡ ");
+    }
+}

package/src/reporter.ts

@@ -4,8 +4,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { Progress } from "#tools";
-import colors from "ansi-colors";
 import { FailureDetail } from "./failure-detail.js";
 
 export type Stats = {
@@ -30,148 +28,3 @@ export interface Failure {
     step?: string;
     detail: FailureDetail;
 }
-
-export abstract class ProgressReporter implements Reporter {
-    #run = "";
-    #suite = Array<string>();
-    #test?: string;
-    #step?: string;
-    #stats?: Stats;
-    #failures = Array<Failure>();
-    #lastTitle?: string;
-
-    constructor(private progress: Progress) {}
-
-    beginRun(name: string, stats: Stats | undefined, supportsSuites = true): void {
-        this.#run = name;
-        this.#suite = [];
-        this.#failures = [];
-        if (!supportsSuites) {
-            this.progress.update(this.#summarize(stats));
-        }
-    }
-
-    beginSuite(name: string[]): void {
-        this.#suite = name;
-    }
-
-    beginTest(name: string, stats?: Stats): void {
-        this.#test = name;
-        this.#stats = stats;
-        this.#step = undefined;
-
-        // If not a TTY, only update once per suite to keep the line count down for e.g. GH action logs
-        const title = process.stdout.isTTY ? this.#formatName(this.#suite, name) : this.#suite[0];
-        this.#updateTitle(title);
-    }
-
-    beginStep(name: string): void {
-        this.#step = name;
-
-        if (process.stdout.isTTY && this.#test) {
-            const title = this.#formatName(this.#suite, this.#test, name);
-            this.#updateTitle(title);
-        }
-    }
-
-    #updateTitle(title: string) {
-        if (title === this.#lastTitle) {
-            return;
-        }
-        this.#lastTitle = title;
-        this.progress.update(this.#summarize(this.#stats), title);
-    }
-
-    failTest(name: string, detail: FailureDetail) {
-        this.#failures.push({
-            suite: this.#suite,
-            test: name,
-            step: this.#step,
-            detail,
-        });
-    }
-
-    abstract failRun(detail: FailureDetail): void;
-
-    endRun(stats?: Stats): void {
-        if (this.#failures.length) {
-            this.progress.failure(this.#summarize(stats));
-            this.#dumpFailures();
-        } else if (stats && !stats.complete) {
-            this.progress.failure("No tests found");
-        } else {
-            this.progress.success(this.#summarize(stats));
-        }
-    }
-
-    #summarize(stats?: Stats) {
-        let statStr;
-        if (stats) {
-            const complete = colors.dim(`${stats.complete}/${stats.total}`);
-            const failures = stats.failures ? colors.redBright(` ${stats.failures.toString()} failed`) : "";
-            statStr = ` ${complete}${failures}`;
-        } else {
-            statStr = "";
-        }
-
-        return `${colors.bold(this.#run)}${statStr}`;
-    }
-
-    #dumpFailures() {
-        for (let i = 0; i < this.#failures.length; i++) {
-            const failure = this.#failures[i];
-            const index = `Failure ${colors.bold((i + 1).toString())} of ${this.#failures.length}`;
-            process.stdout.write(`\n${index} ${this.#formatName(failure.suite, failure.test, failure.step)}\n\n`);
-
-            FailureDetail.dump(failure.detail, "  ");
-        }
-    }
-
-    #formatName(suite: string[], test: string, step?: string) {
-        const breadcrumb = [...suite, test];
-        if (step) {
-            breadcrumb.push(step);
-        }
-        breadcrumb[breadcrumb.length - 1] = colors.bold(breadcrumb[breadcrumb.length - 1]);
-        return breadcrumb.join(" ➡ ");
-    }
-}
-
-const actualConsole = console;
-const actualLog = actualConsole.log;
-
-function proxy(...args: any[]) {
-    actualLog.call(actualConsole, `${ConsoleProxyReporter.FLAG}${JSON.stringify(args)}`);
-}
-
-export class ConsoleProxyReporter implements Reporter {
-    static FLAG = "<<REPORT>> ";
-
-    beginRun(name: string, stats?: Stats) {
-        proxy("beginRun", name, stats);
-    }
-
-    beginSuite(name: string[], stats?: Stats) {
-        proxy("beginSuite", name, stats);
-    }
-
-    beginTest(name: string, stats?: Stats) {
-        proxy("beginTest", name, stats);
-    }
-
-    beginStep(name: string) {
-        proxy("beginStep", name);
-    }
-
-    endRun(stats?: Stats) {
-        proxy("endRun", stats);
-    }
-
-    failTest(name: string, detail: FailureDetail) {
-        proxy("failTest", name, detail);
-    }
-
-    failRun(detail: FailureDetail) {
-        proxy("failRun", detail);
-    }
-}

package/src/runner.ts

@@ -4,15 +4,16 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { Package, Progress } from "#tools";
-import colors from "ansi-colors";
+import { ansi, Package, Progress, std } from "#tools";
 import debug from "debug";
 import { relative } from "path";
 import { chip } from "./chip/chip.js";
 import { FailureDetail } from "./failure-detail.js";
+import { FailureReporter } from "./failure-reporter.js";
+import { NodejsReporter } from "./nodejs-reporter.js";
 import { testNodejs } from "./nodejs.js";
 import { TestOptions } from "./options.js";
-import { ProgressReporter, Reporter } from "./reporter.js";
+import { Reporter } from "./reporter.js";
 import { listSupportFiles } from "./util/files.js";
 import { testWeb } from "./web.js";
 
@@ -27,13 +28,15 @@ export class TestRunner {
     ) {
         chip.runner = this;
 
-        this.reporter = new (class extends ProgressReporter {
+        this.reporter = new (class extends NodejsReporter {
             constructor() {
                 super(progress);
             }
+
             override failRun(detail: FailureDetail) {
-                process.stdout.write("\n");
-                FailureDetail.dump(detail);
+                std.err.write("\n");
+                FailureReporter.report(std.err, detail, "Test suite crash");
+                std.err.write("\n");
                 process.exit(1);
             }
         })();
@@ -87,6 +90,6 @@ export class TestRunner {
 }
 
 function fatal(message: string) {
-    process.stderr.write(colors.redBright(`\n${message}\n\n`));
+    std.err.write(ansi.bright.red(`\n${message}\n\n`));
     process.exit(1);
 }

package/src/text-diff.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export function TextDiff(actual: string, expected: string) {
+    if (TextDiff.generator) {
+        return TextDiff.generator(actual, expected);
+    }
+    return "(no diff generator installed)";
+}
+
+export namespace TextDiff {
+    export let generator: undefined | ((actual: string, expected: string) => string);
+}

package/src/tsconfig.json

@@ -8,5 +8,9 @@
     "include": [
         "**/*.ts"
     ],
-    "references": []
+    "references": [
+        {
+            "path": "../../tools/src"
+        }
+    ]
 }

package/src/web-reporter.ts

@@ -0,0 +1,51 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { FailureDetail } from "./failure-detail.js";
+import { Reporter, Stats } from "./reporter.js";
+
+// Save these so we can avoid any trapping logic and write directly to the console
+const actualConsole = console;
+const actualLog = actualConsole.log;
+function proxy(...args: any[]) {
+    actualLog.call(actualConsole, `${WebReporter.FLAG}${JSON.stringify(args)}`);
+}
+
+/**
+ * Test UI for web browsers.  Encodes each reporting method to the console.  This is a simple way to convey messages
+ * from the browser to the test harness.
+ */
+export class WebReporter implements Reporter {
+    static FLAG = "<<REPORT>> ";
+
+    beginRun(name: string, stats?: Stats) {
+        proxy("beginRun", name, stats);
+    }
+
+    beginSuite(name: string[], stats?: Stats) {
+        proxy("beginSuite", name, stats);
+    }
+
+    beginTest(name: string, stats?: Stats) {
+        proxy("beginTest", name, stats);
+    }
+
+    beginStep(name: string) {
+        proxy("beginStep", name);
+    }
+
+    endRun(stats?: Stats) {
+        proxy("endRun", stats);
+    }
+
+    failTest(name: string, detail: FailureDetail) {
+        proxy("failTest", name, detail);
+    }
+
+    failRun(detail: FailureDetail) {
+        proxy("failRun", detail);
+    }
+}

package/src/web.ts

@@ -13,8 +13,9 @@ import { AddressInfo } from "net";
 import { relative } from "path";
 import { Browser, chromium, ConsoleMessage, Page } from "playwright";
 import { TestOptions } from "./options.js";
-import { ConsoleProxyReporter, Reporter } from "./reporter.js";
+import { Reporter } from "./reporter.js";
 import type { TestRunner } from "./runner.js";
+import { WebReporter } from "./web-reporter.js";
 
 export async function testWeb(runner: TestRunner, manual: boolean) {
     const files = await runner.loadFiles("esm");
@@ -105,13 +106,13 @@ function consoleHandler(reporter: Reporter) {
         const text = message.text();
 
         // If it's not an encoded reporter update, write to normal console
-        if (type !== "log" || !text.startsWith(ConsoleProxyReporter.FLAG)) {
+        if (type !== "log" || !text.startsWith(WebReporter.FLAG)) {
             console[type](text);
             return;
         }
 
         // Invoke reporter
-        const args: string[] = JSON.parse(text.slice(ConsoleProxyReporter.FLAG.length));
+        const args: string[] = JSON.parse(text.slice(WebReporter.FLAG.length));
         const method = (reporter as any)[args[0]];
         if (typeof method !== "function") {
             throw new Error(`Invalid encoded reporter update method ${args[0]}`);