@matter/testing 0.14.1-alpha.0-20250607-a93593303 → 0.15.0-alpha.0-20250613-a55f991d4

package/src/mocks/crypto.ts

@@ -4,67 +4,113 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-const subtle = globalThis.crypto.subtle;
+import { Boot } from "./boot.js";
 
 /**
- * An extremely minimal Crypto mock.
- *
- * Only supports those subsets of crypto required to complete matter.js tests.
+ * An arbitrary fill byte for mock random data.  At some point a pseudo-random function may make sense but for now this
+ * suffices.  Do not choose 0 or 0xff because that will interfere with logic that disallows 0 or -1.
  */
-const TheCrypto = {
-    getRandomData: (length: number) => {
-        // Make random data deterministic
-        const bytes = new Uint8Array(length);
+const FILL_BYTE = 0x80;
 
-        return bytes;
+interface CryptoInstance {
+    getRandomData(length: number): Uint8Array;
+}
+
+interface CryptoNamespace {
+    default: CryptoInstance;
+}
+
+let RealCrypto: undefined | CryptoNamespace;
+
+let restoreRandomness: undefined | (() => void);
+
+export const MockCrypto: MockCrypto = {
+    set random(value: boolean) {
+        if (RealCrypto === undefined) {
+            return;
+        }
+
+        if (value === this.random) {
+            return;
+        }
+
+        restoreRandomness?.();
+        if (!value) {
+            const instance = RealCrypto.default;
+
+            const realGetRandomData = instance.getRandomData;
+            instance.getRandomData = length => {
+                const result = new Uint8Array(length);
+                result.fill(FILL_BYTE);
+                return result;
+            };
+
+            restoreRandomness = () => {
+                instance.getRandomData = realGetRandomData;
+                restoreRandomness = undefined;
+            };
+        }
     },
 
-    async pbkdf2(secret: Uint8Array, salt: Uint8Array, iteration: number, keyLength: number) {
-        const key = await subtle.importKey("raw", secret, "PBKDF2", false, ["deriveBits"]);
-        const bits = await subtle.deriveBits(
-            {
-                name: "PBKDF2",
-                hash: "SHA-256",
-                salt: salt,
-                iterations: iteration,
-            },
-            key,
-            keyLength * 8,
-        );
-        return new Uint8Array(bits);
+    get random() {
+        return !restoreRandomness;
     },
 
-    async hkdf(secret: Uint8Array, salt: Uint8Array, info: Uint8Array, length: number = 16) {
-        const key = await subtle.importKey("raw", secret, "HKDF", false, ["deriveBits"]);
-        return new Uint8Array(
-            await subtle.deriveBits(
-                {
-                    name: "HKDF",
-                    hash: "SHA-256",
-                    salt: salt,
-                    info: info,
-                },
-                key,
-                length,
-            ),
-        );
+    withRandom<T>(value: boolean, actor: () => T): T {
+        const revertTo = !!restoreRandomness;
+        let isAsync = false;
+        try {
+            MockCrypto.random = value;
+            const result = actor();
+            if (typeof (result as any)?.then === "function") {
+                isAsync = true;
+                return Promise.resolve(result).finally(() => {
+                    MockCrypto.random = revertTo;
+                }) as T;
+            }
+            return result;
+        } finally {
+            if (!isAsync) {
+                MockCrypto.random = revertTo;
+            }
+        }
     },
 
-    verify() {
-        // We do not really verify anything
-        return;
+    enable() {
+        MockCrypto.random = false;
     },
 
-    mock: true,
+    init() {
+        if (MockCrypto.random) {
+            MockCrypto.enable();
+        }
+    },
 };
 
-export function cryptoSetup(Crypto: any) {
-    try {
-        Crypto.get();
-    } catch (e) {
-        if ((e as Error).constructor.name !== "NoProviderError") {
-            throw e;
-        }
-        Crypto.get = () => TheCrypto;
-    }
+export function cryptoSetup(Crypto: CryptoNamespace) {
+    RealCrypto = Crypto;
+}
+
+Boot.init(() => (MockCrypto.random = true));
+
+export interface MockCrypto {
+    /**
+     * If false, crypto functions return all zeros instead of random data.  Resets to true for each test file.
+     */
+    random: boolean;
+
+    /**
+     * Set {@link random} to false.
+     */
+    enable(): void;
+
+    /**
+     * Enabled if not already enabled.
+     */
+    init(): void;
+
+    /**
+     * Perform an operation with altered {@link random} then revert.
+     */
+    withRandom<T>(value: boolean, actor: () => T): T;
 }

package/src/mocks/logging.ts

@@ -25,7 +25,7 @@ export interface MockLogger {
     injectExternalMessage: (source: string, text: string) => void;
 }
 
-export const TheMockLogger: MockLogger = {
+export const MockLogger: MockLogger = {
     emitAll: false,
     injectExternalMessage: (source: string, text: string) => console.log(formatExternalMessage(source, text)),
 };
@@ -67,7 +67,7 @@ export function loggerSetup(Logger: LoggerLike) {
     }
 
     function interceptingWriter(...args: [string, DiagnosticMessageLike]) {
-        let emitAll = TheMockLogger.emitAll;
+        let emitAll = MockLogger.emitAll;
         if (MatterHooks?.loggerSink) {
             MatterHooks.loggerSink(...args);
         } else if (!emitAll) {
@@ -83,14 +83,14 @@ export function loggerSetup(Logger: LoggerLike) {
         }
     }
 
-    TheMockLogger.injectExternalMessage = (source, text) =>
+    MockLogger.injectExternalMessage = (source, text) =>
         interceptingWriter(formatExternalMessage(source, text), { level: 0 });
 
     Logger.destinations.default.write = interceptingWriter;
 
     // Divert log messages for test duration
     LoggerHooks.beforeEach.push(function () {
-        if (!TheMockLogger.emitAll) {
+        if (!MockLogger.emitAll) {
             messageBuffer = [];
         }
     });

package/src/mocks/time.ts

@@ -83,30 +83,74 @@ function isAsync(fn: (...args: any) => any): fn is (...args: any) => Promise<any
 let callbacks = new Array<{ atMs: number; callback: TimerCallback }>();
 let nowMs = 0;
 let real = undefined as unknown;
-let enabled = true;
+let enabled = false;
 
-// Must match matter.js Time interface
+/**
+ * An arbitrary start for our mock timeline.  Starting at zero causes problems with Matter dates that cannot encode back
+ * to the UNIX epoch
+ */
+const epoch = new Date("2025-01-01 12:34:56Z");
+
+// Must match matter.js Time interface (with extensions)
 export const MockTime = {
+    epoch,
+
     get activeImplementation(): unknown {
         return enabled ? this : (real ?? this);
     },
 
+    /**
+     * Revert to standard time implementation.
+     */
     disable() {
         enabled = false;
-        reinstallTime?.();
+        installActiveImplementation?.();
     },
 
+    /**
+     * Enable time mocking.  Reverts to disabled for each test file.
+     */
     enable() {
         enabled = true;
-        reinstallTime?.();
+        installActiveImplementation?.();
     },
 
-    reset(time = 0) {
+    /**
+     * Sets mock time to specific time and enable the mock.
+     */
+    reset(time: ConstructorParameters<typeof Date>[0] = epoch) {
         callbacks = [];
-        nowMs = time;
+        nowMs = new Date(time).getTime();
+        MockTime.enable();
+    },
 
-        // Ensure time reverts to correct implementation across suites
-        this.enable();
+    /**
+     * Enable and reset if not already enabled.
+     */
+    init() {
+        if (!enabled) {
+            MockTime.enable();
+        }
+    },
+
+    atTime<T>(time: number | Date, actor: () => T): T {
+        const revertTo = nowMs;
+        let isAsync = false;
+        try {
+            nowMs = typeof time === "number" ? time : time.getTime();
+            const result = actor();
+            if (typeof (result as any)?.then === "function") {
+                isAsync = true;
+                return Promise.resolve(result).finally(() => {
+                    nowMs = revertTo;
+                }) as T;
+            }
+            return result;
+        } finally {
+            if (!isAsync) {
+                nowMs = revertTo;
+            }
+        }
     },
 
     now(): Date {
@@ -305,7 +349,7 @@ export const MockTime = {
     },
 };
 
-let reinstallTime: undefined | (() => void);
+let installActiveImplementation: undefined | (() => void);
 
 export function timeSetup(Time: {
     startup: { systemMs: number; processMs: number };
@@ -320,12 +364,13 @@ export function timeSetup(Time: {
     Time.startup.systemMs = Time.startup.processMs = 0;
     real = Time.get();
     (MockTime as any).sleep = (real as any).sleep;
-    reinstallTime = () => (Time.get = () => MockTime.activeImplementation);
-    reinstallTime();
+    installActiveImplementation = () => (Time.get = () => MockTime.activeImplementation);
+    installActiveImplementation();
 }
 
 Object.assign(globalThis, { MockTime });
 
 Boot.init(() => {
     MockTime.reset();
+    MockTime.disable();
 });

package/src/nodejs.ts

@@ -15,11 +15,14 @@ import type { TestRunner } from "./runner.js";
 // Load globals so settings get applied
 import { FailureDetail } from "./failure-detail.js";
 import "./global-definitions.js";
+import { Boot } from "./mocks/boot.js";
 import { TestDescriptor } from "./test-descriptor.js";
 
 extendApi(Mocha);
 
 export async function testNodejs(runner: TestRunner, format: "cjs" | "esm") {
+    Boot.format = format;
+
     // Grr Mocha (as of 10.2.0) classifies certain unhandled rejections as "mocha".  For others, it uninstalls its
     // unhandled rejection handler and re-emits the "unhandledRejection" event.  But since it already handled the event,
     // Node knows nothing about this and the event disappears silently.