@grest-ts/testkit 0.0.6 → 0.0.7

package/src/mockable/GGMockableInterceptorsServer.ts

@@ -1,69 +1,69 @@
-import type {GGMockableInterceptor} from "./GGMockableInterceptor";
-import {GGTestComponent} from "../testers/GGTestComponent";
-import {GGTestRunner} from "../GGTestRunner";
-import {GGMockableIPC} from "./GGMockableIPC";
-
-export const CALL_THROUGH = "__spyCallThrough|migo0am5g0htea";
-
-export class GGMockableInterceptorsServer implements GGTestComponent {
-
-    private readonly interceptors: Map<string, GGMockableInterceptor> = new Map();
-
-    constructor(runner: GGTestRunner) {
-        const server = runner.ipcServer;
-        server.onFrameworkMessage(GGMockableIPC.testServer.call, async (body) => {
-            const key = body.className + "." + body.methodName;
-            const handler = this.interceptors.get(key);
-
-            if (!handler) {
-                // No mock configured - call through to real implementation
-                // This allows testable() to invoke real methods on @mockable services
-                // throw new Error(
-                //     `Expected handler to be set for mockable '${key}'!\n` +
-                //     "Did you forget to call .with(...)?"
-                // );
-                return CALL_THROUGH;
-            }
-
-            // onRequest validates input and returns mock data (or undefined for spy)
-            const result = await handler.onRequest(body.callArgs);
-
-            if (handler.passThrough) {
-                // Spy mode - signal worker to call through
-                return CALL_THROUGH;
-            } else {
-                // Mock mode - return the mock data
-                return result;
-            }
-        });
-
-        server.onFrameworkMessage(GGMockableIPC.testServer.spyResult, async (body) => {
-            const key = body.className + "." + body.methodName;
-            const handler = this.interceptors.get(key);
-
-            if (!handler || !handler.passThrough) {
-                // No spy handler configured - just ignore the result
-                // This allows testable() to call through without requiring spyOn()
-                // throw new Error(`Expected spy handler for '${key}'`);
-                return;
-            }
-
-            // Validate the response from the real implementation
-            await handler.onResponse(body.callResult);
-        });
-    }
-
-    public addInterceptor(interceptor: GGMockableInterceptor) {
-        this.interceptors.set(interceptor.getKey(), interceptor);
-    }
-
-    public deleteInterceptor(interceptor: GGMockableInterceptor) {
-        this.interceptors.delete(interceptor.getKey());
-    }
-
-    public async teardown(): Promise<void> {
-        this.interceptors.clear();
-    }
-}
-
-GGTestRunner.registerExtension(GGMockableInterceptorsServer);
+import type {GGMockableInterceptor} from "./GGMockableInterceptor";
+import {GGTestComponent} from "../testers/GGTestComponent";
+import {GGTestRunner} from "../GGTestRunner";
+import {GGMockableIPC} from "./GGMockableIPC";
+
+export const CALL_THROUGH = "__spyCallThrough|migo0am5g0htea";
+
+export class GGMockableInterceptorsServer implements GGTestComponent {
+
+    private readonly interceptors: Map<string, GGMockableInterceptor> = new Map();
+
+    constructor(runner: GGTestRunner) {
+        const server = runner.ipcServer;
+        server.onFrameworkMessage(GGMockableIPC.testServer.call, async (body) => {
+            const key = body.className + "." + body.methodName;
+            const handler = this.interceptors.get(key);
+
+            if (!handler) {
+                // No mock configured - call through to real implementation
+                // This allows testable() to invoke real methods on @mockable services
+                // throw new Error(
+                //     `Expected handler to be set for mockable '${key}'!\n` +
+                //     "Did you forget to call .with(...)?"
+                // );
+                return CALL_THROUGH;
+            }
+
+            // onRequest validates input and returns mock data (or undefined for spy)
+            const result = await handler.onRequest(body.callArgs);
+
+            if (handler.passThrough) {
+                // Spy mode - signal worker to call through
+                return CALL_THROUGH;
+            } else {
+                // Mock mode - return the mock data
+                return result;
+            }
+        });
+
+        server.onFrameworkMessage(GGMockableIPC.testServer.spyResult, async (body) => {
+            const key = body.className + "." + body.methodName;
+            const handler = this.interceptors.get(key);
+
+            if (!handler || !handler.passThrough) {
+                // No spy handler configured - just ignore the result
+                // This allows testable() to call through without requiring spyOn()
+                // throw new Error(`Expected spy handler for '${key}'`);
+                return;
+            }
+
+            // Validate the response from the real implementation
+            await handler.onResponse(body.callResult);
+        });
+    }
+
+    public addInterceptor(interceptor: GGMockableInterceptor) {
+        this.interceptors.set(interceptor.getKey(), interceptor);
+    }
+
+    public deleteInterceptor(interceptor: GGMockableInterceptor) {
+        this.interceptors.delete(interceptor.getKey());
+    }
+
+    public async teardown(): Promise<void> {
+        this.interceptors.clear();
+    }
+}
+
+GGTestRunner.registerExtension(GGMockableInterceptorsServer);

package/src/mockable/mockable.ts

@@ -1,71 +1,71 @@
-/**
- * Mockable decorator and test helpers.
- *
- * The @mockable decorator is re-exported from mockable-runtime.ts for production use.
- * mockBy() and spyOn() are test-only utilities that require the full testkit.
- */
-
-// Test-only imports - these pull in testkit infrastructure
-import {GGMockableInterceptor} from "./GGMockableInterceptor";
-import {GGMockWith} from "../testers/GGMockWith";
-import {GGSpyWith} from "../testers/GGSpyWith";
-
-// ============================================================================
-// Type helpers for mockBy/spyOn
-// ============================================================================
-
-/**
- * Type for mock access - maps class methods to GGMockWith
- */
-type MockAccess<T> = {
-    [K in keyof T]: T[K] extends (...args: infer A) => Promise<infer R>
-        ? GGMockWith<A extends [infer Single] ? (Single extends object ? Single : Record<string, Single>) : Record<string, any>, Awaited<R>, never>
-        : never
-};
-
-/**
- * Type for spy access - maps class methods to GGSpyWith
- */
-type SpyAccess<T> = {
-    [K in keyof T]: T[K] extends (...args: infer A) => Promise<infer R>
-        ? GGSpyWith<A extends [infer Single] ? (Single extends object ? Single : Record<string, Single>) : Record<string, any>, Awaited<R>, never>
-        : never
-};
-
-/**
- * Get mock access for a @mockable class.
- * Use this to create mock expectations in tests.
- *
- * @example
- * ```typescript
- * .with(mockOf(AddressResolverService).resolveAddress
- *     .toEqual({address: "123 Main St"})
- *     .andReturn({lat: 40.7, lng: -74.0}))
- * ```
- */
-export function mockOf<T>(cls: new (...args: any[]) => T): MockAccess<T> {
-    return new Proxy({} as any, {
-        get(_, methodName: string) {
-            return new GGMockWith(GGMockableInterceptor, {className: cls.name, methodName})
-        }
-    });
-}
-
-/**
- * Get spy access for a @mockable class.
- * Use this to create spy expectations in tests - the real method will be called.
- *
- * @example
- * ```typescript
- * .with(spyOn(AddressResolverService).resolveAddress
- *     .toEqual({address: "123 Main St"})
- *     .responseToMatchObject({lat: 40.7}))
- * ```
- */
-export function spyOn<T>(cls: new (...args: any[]) => T): SpyAccess<T> {
-    return new Proxy({} as any, {
-        get(_, methodName: string) {
-            return new GGSpyWith(GGMockableInterceptor, {className: cls.name, methodName})
-        }
-    });
-}
+/**
+ * Mockable decorator and test helpers.
+ *
+ * The @mockable decorator is re-exported from mockable-runtime.ts for production use.
+ * mockBy() and spyOn() are test-only utilities that require the full testkit.
+ */
+
+// Test-only imports - these pull in testkit infrastructure
+import {GGMockableInterceptor} from "./GGMockableInterceptor";
+import {GGMockWith} from "../testers/GGMockWith";
+import {GGSpyWith} from "../testers/GGSpyWith";
+
+// ============================================================================
+// Type helpers for mockBy/spyOn
+// ============================================================================
+
+/**
+ * Type for mock access - maps class methods to GGMockWith
+ */
+type MockAccess<T> = {
+    [K in keyof T]: T[K] extends (...args: infer A) => Promise<infer R>
+        ? GGMockWith<A extends [infer Single] ? (Single extends object ? Single : Record<string, Single>) : Record<string, any>, Awaited<R>, never>
+        : never
+};
+
+/**
+ * Type for spy access - maps class methods to GGSpyWith
+ */
+type SpyAccess<T> = {
+    [K in keyof T]: T[K] extends (...args: infer A) => Promise<infer R>
+        ? GGSpyWith<A extends [infer Single] ? (Single extends object ? Single : Record<string, Single>) : Record<string, any>, Awaited<R>, never>
+        : never
+};
+
+/**
+ * Get mock access for a @mockable class.
+ * Use this to create mock expectations in tests.
+ *
+ * @example
+ * ```typescript
+ * .with(mockOf(AddressResolverService).resolveAddress
+ *     .toEqual({address: "123 Main St"})
+ *     .andReturn({lat: 40.7, lng: -74.0}))
+ * ```
+ */
+export function mockOf<T>(cls: new (...args: any[]) => T): MockAccess<T> {
+    return new Proxy({} as any, {
+        get(_, methodName: string) {
+            return new GGMockWith(GGMockableInterceptor, {className: cls.name, methodName})
+        }
+    });
+}
+
+/**
+ * Get spy access for a @mockable class.
+ * Use this to create spy expectations in tests - the real method will be called.
+ *
+ * @example
+ * ```typescript
+ * .with(spyOn(AddressResolverService).resolveAddress
+ *     .toEqual({address: "123 Main St"})
+ *     .responseToMatchObject({lat: 40.7}))
+ * ```
+ */
+export function spyOn<T>(cls: new (...args: any[]) => T): SpyAccess<T> {
+    return new Proxy({} as any, {
+        get(_, methodName: string) {
+            return new GGSpyWith(GGMockableInterceptor, {className: cls.name, methodName})
+        }
+    });
+}

package/src/runner/InlineRunner.ts

@@ -1,47 +1,47 @@
-import type {RuntimeRunner} from "./RuntimeRunner";
-import {GGTestRuntimeWorker} from "../GGTestRuntimeWorker";
-import {GGTestEnvConfig} from "../GGTestRuntime";
-import {GGLocatorScope} from "@grest-ts/locator";
-
-export class InlineRunner implements RuntimeRunner {
-
-    private controlClient?: GGTestRuntimeWorker;
-
-    constructor(
-        private readonly config: GGTestEnvConfig,
-        private readonly runtimeFactory?: () => any
-    ) {
-    }
-
-    async start(): Promise<void> {
-        // Use setTimeout + enterBlank() to create a fully isolated async context.
-        // This gives the inline runtime its own context tree where GGLog.init()
-        // creates an independent log context, similar to how Worker/Isolated modes
-        // naturally get separate contexts by running in different threads/processes.
-        const factory = this.runtimeFactory;
-        await new Promise<void>((resolve, reject) => {
-            setTimeout(async () => {
-                try {
-                    // Create blank context - inline runtime should not inherit test context
-                    new GGLocatorScope("GGInlineRunner").enter();
-                    this.controlClient = new GGTestRuntimeWorker(this.config);
-                    // Pass factory to avoid dynamic import() which causes duplicate
-                    // module loading in Vite/vitest environments
-                    await this.controlClient.start(factory);
-                    resolve();
-                } catch (err) {
-                    reject(err);
-                }
-            }, 0);
-        });
-    }
-
-    async stopRuntime(): Promise<void> {
-        await this.controlClient?.stopRuntime();
-    }
-
-    async shutdown(): Promise<void> {
-        await this.controlClient?.shutdown();
-        this.controlClient = undefined;
-    }
-}
+import type {RuntimeRunner} from "./RuntimeRunner";
+import {GGTestRuntimeWorker} from "../GGTestRuntimeWorker";
+import {GGTestEnvConfig} from "../GGTestRuntime";
+import {GGLocatorScope} from "@grest-ts/locator";
+
+export class InlineRunner implements RuntimeRunner {
+
+    private controlClient?: GGTestRuntimeWorker;
+
+    constructor(
+        private readonly config: GGTestEnvConfig,
+        private readonly runtimeFactory?: () => any
+    ) {
+    }
+
+    async start(): Promise<void> {
+        // Use setTimeout + enterBlank() to create a fully isolated async context.
+        // This gives the inline runtime its own context tree where GGLog.init()
+        // creates an independent log context, similar to how Worker/Isolated modes
+        // naturally get separate contexts by running in different threads/processes.
+        const factory = this.runtimeFactory;
+        await new Promise<void>((resolve, reject) => {
+            setTimeout(async () => {
+                try {
+                    // Create blank context - inline runtime should not inherit test context
+                    new GGLocatorScope("GGInlineRunner").enter();
+                    this.controlClient = new GGTestRuntimeWorker(this.config);
+                    // Pass factory to avoid dynamic import() which causes duplicate
+                    // module loading in Vite/vitest environments
+                    await this.controlClient.start(factory);
+                    resolve();
+                } catch (err) {
+                    reject(err);
+                }
+            }, 0);
+        });
+    }
+
+    async stopRuntime(): Promise<void> {
+        await this.controlClient?.stopRuntime();
+    }
+
+    async shutdown(): Promise<void> {
+        await this.controlClient?.shutdown();
+        this.controlClient = undefined;
+    }
+}