@grest-ts/testkit 0.0.6 → 0.0.7

package/src/callOn/registerOnCallHandler.ts

@@ -1,123 +1,123 @@
-/**
- * Worker-side handler for GGLocator-based service invocation.
- *
- * Receives IPC requests from tests to invoke methods on registered instances
- * (@testable, @contract, etc.) and returns the results.
- */
-
-import {GGLocator, GGLocatorKey} from "@grest-ts/locator";
-import {GGLog} from "@grest-ts/logger";
-import {SerializedContext, TestableIPC, TestableInvokePayload, TestableInvokeResult} from "./TestableIPC";
-import {GGTestRuntimeWorker} from "../GGTestRuntimeWorker";
-import {GGContext} from "@grest-ts/context";
-
-/**
- * Context for logging
- */
-const LOG_CONTEXT = {name: "GGLocatorWorkerHandler"};
-
-/**
- * Deserialize context data into a GGContext.
- * Directly populates the internal values map.
- */
-function deserializeContext(data: SerializedContext): GGContext {
-    const ctx = new GGContext("ipc-context");
-    // Access internal values map and populate directly
-    const ctxAny = ctx as any;
-    for (const [keyName, value] of Object.entries(data)) {
-        ctxAny.values.set(keyName, value);
-    }
-    return ctx;
-}
-
-/**
- * Register the locator lookup handler on the worker.
- * Called during worker initialization.
- */
-export function registerOnCallHandler(worker: GGTestRuntimeWorker): void {
-    worker.onIpcRequest(TestableIPC.invoke, async (payload: TestableInvokePayload): Promise<TestableInvokeResult> => {
-        const {keyName, methodName, args, context} = payload;
-
-        GGLog.debug(LOG_CONTEXT, `Invoking ${keyName}.${methodName}`, {args, hasContext: !!context});
-
-        try {
-            // Look up the instance in the current scope
-            const scope = GGLocator.tryGetScope();
-            if (!scope) {
-                return {
-                    success: false,
-                    error: `No GGLocator scope available - is the runtime running?`
-                };
-            }
-
-            const key = new GGLocatorKey<any>(keyName);
-            const instance = scope.tryGet(key);
-
-            if (!instance) {
-                return {
-                    success: false,
-                    error: `Instance '${keyName}' not found in GGLocator. ` +
-                        `Make sure the class is decorated with @testable or registered during compose().`
-                };
-            }
-
-            // Check if method exists
-            const method = instance[methodName];
-            if (typeof method !== 'function') {
-                return {
-                    success: false,
-                    error: `Method '${methodName}' not found on instance '${keyName}'. ` +
-                        `Available methods: ${getMethodNames(instance).join(', ')}`
-                };
-            }
-
-            // Invoke the method, optionally within the provided context
-            let result: any;
-            if (context) {
-                const ctx = deserializeContext(context);
-                result = await ctx.run(() => method.apply(instance, args));
-            } else {
-                result = await method.apply(instance, args);
-            }
-
-            GGLog.debug(LOG_CONTEXT, `Invocation ${keyName}.${methodName} completed`, {result});
-
-            return {
-                success: true,
-                result
-            };
-        } catch (error: any) {
-            GGLog.error(LOG_CONTEXT, `Error invoking ${keyName}.${methodName}`, error);
-
-            return {
-                success: false,
-                error: error.message || String(error),
-                stack: error.stack
-            };
-        }
-    });
-}
-
-/**
- * Get method names from an instance for error messages.
- */
-function getMethodNames(instance: any): string[] {
-    const names: string[] = [];
-    let proto = Object.getPrototypeOf(instance);
-
-    while (proto && proto !== Object.prototype) {
-        const propNames = Object.getOwnPropertyNames(proto)
-            .filter(name => {
-                if (name === 'constructor') return false;
-                try {
-                    return typeof proto[name] === 'function';
-                } catch {
-                    return false;
-                }
-            });
-        names.push(...propNames);
-        proto = Object.getPrototypeOf(proto);
-    }
-
-    return [...new Set(names)].sort();
-}
+/**
+ * Worker-side handler for GGLocator-based service invocation.
+ *
+ * Receives IPC requests from tests to invoke methods on registered instances
+ * (@testable, @contract, etc.) and returns the results.
+ */
+
+import {GGLocator, GGLocatorKey} from "@grest-ts/locator";
+import {GGLog} from "@grest-ts/logger";
+import {SerializedContext, TestableIPC, TestableInvokePayload, TestableInvokeResult} from "./TestableIPC";
+import {GGTestRuntimeWorker} from "../GGTestRuntimeWorker";
+import {GGContext} from "@grest-ts/context";
+
+/**
+ * Context for logging
+ */
+const LOG_CONTEXT = {name: "GGLocatorWorkerHandler"};
+
+/**
+ * Deserialize context data into a GGContext.
+ * Directly populates the internal values map.
+ */
+function deserializeContext(data: SerializedContext): GGContext {
+    const ctx = new GGContext("ipc-context");
+    // Access internal values map and populate directly
+    const ctxAny = ctx as any;
+    for (const [keyName, value] of Object.entries(data)) {
+        ctxAny.values.set(keyName, value);
+    }
+    return ctx;
+}
+
+/**
+ * Register the locator lookup handler on the worker.
+ * Called during worker initialization.
+ */
+export function registerOnCallHandler(worker: GGTestRuntimeWorker): void {
+    worker.onIpcRequest(TestableIPC.invoke, async (payload: TestableInvokePayload): Promise<TestableInvokeResult> => {
+        const {keyName, methodName, args, context} = payload;
+
+        GGLog.debug(LOG_CONTEXT, `Invoking ${keyName}.${methodName}`, {args, hasContext: !!context});
+
+        try {
+            // Look up the instance in the current scope
+            const scope = GGLocator.tryGetScope();
+            if (!scope) {
+                return {
+                    success: false,
+                    error: `No GGLocator scope available - is the runtime running?`
+                };
+            }
+
+            const key = new GGLocatorKey<any>(keyName);
+            const instance = scope.tryGet(key);
+
+            if (!instance) {
+                return {
+                    success: false,
+                    error: `Instance '${keyName}' not found in GGLocator. ` +
+                        `Make sure the class is decorated with @testable or registered during compose().`
+                };
+            }
+
+            // Check if method exists
+            const method = instance[methodName];
+            if (typeof method !== 'function') {
+                return {
+                    success: false,
+                    error: `Method '${methodName}' not found on instance '${keyName}'. ` +
+                        `Available methods: ${getMethodNames(instance).join(', ')}`
+                };
+            }
+
+            // Invoke the method, optionally within the provided context
+            let result: any;
+            if (context) {
+                const ctx = deserializeContext(context);
+                result = await ctx.run(() => method.apply(instance, args));
+            } else {
+                result = await method.apply(instance, args);
+            }
+
+            GGLog.debug(LOG_CONTEXT, `Invocation ${keyName}.${methodName} completed`, {result});
+
+            return {
+                success: true,
+                result
+            };
+        } catch (error: any) {
+            GGLog.error(LOG_CONTEXT, `Error invoking ${keyName}.${methodName}`, error);
+
+            return {
+                success: false,
+                error: error.message || String(error),
+                stack: error.stack
+            };
+        }
+    });
+}
+
+/**
+ * Get method names from an instance for error messages.
+ */
+function getMethodNames(instance: any): string[] {
+    const names: string[] = [];
+    let proto = Object.getPrototypeOf(instance);
+
+    while (proto && proto !== Object.prototype) {
+        const propNames = Object.getOwnPropertyNames(proto)
+            .filter(name => {
+                if (name === 'constructor') return false;
+                try {
+                    return typeof proto[name] === 'function';
+                } catch {
+                    return false;
+                }
+            });
+        names.push(...propNames);
+        proto = Object.getPrototypeOf(proto);
+    }
+
+    return [...new Set(names)].sort();
+}

package/src/index-node.ts

@@ -1,64 +1,64 @@
-/**
- * @grest-ts/testkit - Component testing library
- */
-
-// Core test framework
-import path from "path";
-import {fileURLToPath} from "url";
-import {WorkerRunner} from "./runner/WorkerRunner";
-import {IsolatedRunner} from "./runner/IsolatedRunner";
-
-export * from './GGTest'
-export * from './GGTestRunner'
-export * from './IGGLocalDiscoveryServer'
-export * from './GGTestRuntime'
-export * from './testers/GGTestComponent'
-export * from './mockable/GGMockable'
-export * from './mockable/GGMockableCall'
-export * from './mockable/mockable'
-export * from './GGTestContext'
-
-// Mockable component server (import triggers factory registration)
-export * from './mockable/GGMockableInterceptorsServer'
-
-// Testable - direct service invocation from tests
-export * from './callOn/callOn'
-export * from './callOn/GGTestActionForLocatorOnCall'
-export * from './callOn/GGCallOnSelector'
-
-// Contract registration - patches GGContractClass.implement() to auto-register
-import './callOn/GGContractClass.implement'
-
-// Control channel for runtime config updates
-export * from './GGTestRuntimeWorker'
-
-// Test utilities - core infrastructure
-export * from './testers/IGGTestWith'
-export * from './testers/GGTestAction'
-export * from './testers/GGMockWith'
-export * from './testers/GGSpyWith'
-export * from './testers/GGCallInterceptor'
-export * from './utils/GGExpectations'
-export * from './utils/GGTestError'
-export {captureStackSourceFile} from './utils/captureStack'
-export * from './GGTestSharedRef'
-
-// Production bundle DCE verification
-export * from './GGBundleTest'
-
-// Mockable interceptor
-export * from './mockable/GGMockableInterceptor'
-
-// Selector system for runtime access
-export * from './testers/GGTestSelector'
-export * from './testers/RuntimeSelector'
-
-// Worker runner (path configured by @grest-ts/testkit-vitest)
-export * from './runner/WorkerRunner'
-
-export type * from "./testers/IGGTestWith";
-export type * from "./testers/IGGTestInterceptor";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-WorkerRunner.setWorkerLoaderPath(path.join(__dirname, 'runner', 'worker-loader.mjs'));
-IsolatedRunner.setIsolatedLoaderPath(path.join(__dirname, 'runner', 'isolated-loader.mjs'));
+/**
+ * @grest-ts/testkit - Component testing library
+ */
+
+// Core test framework
+import path from "path";
+import {fileURLToPath} from "url";
+import {WorkerRunner} from "./runner/WorkerRunner";
+import {IsolatedRunner} from "./runner/IsolatedRunner";
+
+export * from './GGTest'
+export * from './GGTestRunner'
+export * from './IGGLocalDiscoveryServer'
+export * from './GGTestRuntime'
+export * from './testers/GGTestComponent'
+export * from './mockable/GGMockable'
+export * from './mockable/GGMockableCall'
+export * from './mockable/mockable'
+export * from './GGTestContext'
+
+// Mockable component server (import triggers factory registration)
+export * from './mockable/GGMockableInterceptorsServer'
+
+// Testable - direct service invocation from tests
+export * from './callOn/callOn'
+export * from './callOn/GGTestActionForLocatorOnCall'
+export * from './callOn/GGCallOnSelector'
+
+// Contract registration - patches GGContractClass.implement() to auto-register
+import './callOn/GGContractClass.implement'
+
+// Control channel for runtime config updates
+export * from './GGTestRuntimeWorker'
+
+// Test utilities - core infrastructure
+export * from './testers/IGGTestWith'
+export * from './testers/GGTestAction'
+export * from './testers/GGMockWith'
+export * from './testers/GGSpyWith'
+export * from './testers/GGCallInterceptor'
+export * from './utils/GGExpectations'
+export * from './utils/GGTestError'
+export {captureStackSourceFile} from './utils/captureStack'
+export * from './GGTestSharedRef'
+
+// Production bundle DCE verification
+export * from './GGBundleTest'
+
+// Mockable interceptor
+export * from './mockable/GGMockableInterceptor'
+
+// Selector system for runtime access
+export * from './testers/GGTestSelector'
+export * from './testers/RuntimeSelector'
+
+// Worker runner (path configured by @grest-ts/testkit-vitest)
+export * from './runner/WorkerRunner'
+
+export type * from "./testers/IGGTestWith";
+export type * from "./testers/IGGTestInterceptor";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+WorkerRunner.setWorkerLoaderPath(path.join(__dirname, 'runner', 'worker-loader.mjs'));
+IsolatedRunner.setIsolatedLoaderPath(path.join(__dirname, 'runner', 'isolated-loader.mjs'));

package/src/mockable/GGMockable.ts

@@ -1,22 +1,22 @@
-/**
- * Marker interface for external API services that can be mocked in tests.
- * When a class implements this interface, the test framework can intercept
- * all method calls and provide mock responses.
- *
- * Examples: REST APIs, GraphQL clients, third-party SDKs
- */
-export interface GGMockableExternalApi {
-    // Marker interface - no methods required
-}
-
-/**
- * Marker interface for database/storage services that can be mocked in tests.
- * When a class implements this interface, the test framework can intercept
- * all method calls and provide mock responses.
- *
- * Examples: Database clients, cache services, file storage
- */
-export interface GGMockableDatabaseApi {
-    // Marker interface - no methods required
-}
-
+/**
+ * Marker interface for external API services that can be mocked in tests.
+ * When a class implements this interface, the test framework can intercept
+ * all method calls and provide mock responses.
+ *
+ * Examples: REST APIs, GraphQL clients, third-party SDKs
+ */
+export interface GGMockableExternalApi {
+    // Marker interface - no methods required
+}
+
+/**
+ * Marker interface for database/storage services that can be mocked in tests.
+ * When a class implements this interface, the test framework can intercept
+ * all method calls and provide mock responses.
+ *
+ * Examples: Database clients, cache services, file storage
+ */
+export interface GGMockableDatabaseApi {
+    // Marker interface - no methods required
+}
+

package/src/mockable/GGMockableCall.ts

@@ -1,45 +1,45 @@
-import {GG_TEST_RUNTIME_WORKER} from "../GGTestRuntimeWorker";
-import {CALL_THROUGH} from "./GGMockableInterceptorsServer";
-import {GGMockableIPC} from "./GGMockableIPC";
-
-const MOCKABLE_WRAPPED = Symbol('GGMockableWrapped');
-
-export function GGMockableCall(cls: any, methodName: string, nameMapping: string[]): void {
-    // Skip if already wrapped (happens in INLINE mode with multiple runtime instances)
-    if (cls.prototype[methodName]?.[MOCKABLE_WRAPPED]) {
-        return;
-    }
-
-    const originalMethod = cls.prototype[methodName];
-    const wrappedMethod = async function (this: any, ...inputArgs: any[]) {
-        const worker = GG_TEST_RUNTIME_WORKER.get();
-
-        const args: any = {}
-        for (let i = 0; i < inputArgs.length; i++) {
-            if (!nameMapping[i]) break;
-            args[nameMapping[i]] = inputArgs[i];
-        }
-
-        const result = await worker.ipcClient.sendFrameworkRequest(GGMockableIPC.testServer.call, {
-            className: cls.name,
-            methodName: methodName,
-            callArgs: args
-        });
-
-        if (result === CALL_THROUGH) {
-            const realResult = await originalMethod.apply(this, inputArgs);
-            await worker.ipcClient.sendFrameworkRequest(GGMockableIPC.testServer.spyResult, {
-                className: cls.name,
-                methodName: methodName,
-                callResult: realResult
-            });
-            return realResult;
-        } else {
-            return result;
-        }
-    };
-
-    // Mark as wrapped and assign to prototype
-    (wrappedMethod as any)[MOCKABLE_WRAPPED] = true;
-    cls.prototype[methodName] = wrappedMethod;
-}
+import {GG_TEST_RUNTIME_WORKER} from "../GGTestRuntimeWorker";
+import {CALL_THROUGH} from "./GGMockableInterceptorsServer";
+import {GGMockableIPC} from "./GGMockableIPC";
+
+const MOCKABLE_WRAPPED = Symbol('GGMockableWrapped');
+
+export function GGMockableCall(cls: any, methodName: string, nameMapping: string[]): void {
+    // Skip if already wrapped (happens in INLINE mode with multiple runtime instances)
+    if (cls.prototype[methodName]?.[MOCKABLE_WRAPPED]) {
+        return;
+    }
+
+    const originalMethod = cls.prototype[methodName];
+    const wrappedMethod = async function (this: any, ...inputArgs: any[]) {
+        const worker = GG_TEST_RUNTIME_WORKER.get();
+
+        const args: any = {}
+        for (let i = 0; i < inputArgs.length; i++) {
+            if (!nameMapping[i]) break;
+            args[nameMapping[i]] = inputArgs[i];
+        }
+
+        const result = await worker.ipcClient.sendFrameworkRequest(GGMockableIPC.testServer.call, {
+            className: cls.name,
+            methodName: methodName,
+            callArgs: args
+        });
+
+        if (result === CALL_THROUGH) {
+            const realResult = await originalMethod.apply(this, inputArgs);
+            await worker.ipcClient.sendFrameworkRequest(GGMockableIPC.testServer.spyResult, {
+                className: cls.name,
+                methodName: methodName,
+                callResult: realResult
+            });
+            return realResult;
+        } else {
+            return result;
+        }
+    };
+
+    // Mark as wrapped and assign to prototype
+    (wrappedMethod as any)[MOCKABLE_WRAPPED] = true;
+    cls.prototype[methodName] = wrappedMethod;
+}

package/src/mockable/GGMockableIPC.ts

@@ -1,20 +1,20 @@
-import {IPCServer} from "@grest-ts/ipc";
-
-export interface MockableCallPayload {
-    className: string;
-    methodName: string;
-    callArgs: any;
-}
-
-export interface MockableSpyResultPayload {
-    className: string;
-    methodName: string;
-    callResult: any;
-}
-
-export const GGMockableIPC = {
-    testServer: {
-        call: IPCServer.defineRequest<MockableCallPayload, any>("mockable/call"),
-        spyResult: IPCServer.defineRequest<MockableSpyResultPayload, any>("mockable/spy-result"),
-    }
-}
+import {IPCServer} from "@grest-ts/ipc";
+
+export interface MockableCallPayload {
+    className: string;
+    methodName: string;
+    callArgs: any;
+}
+
+export interface MockableSpyResultPayload {
+    className: string;
+    methodName: string;
+    callResult: any;
+}
+
+export const GGMockableIPC = {
+    testServer: {
+        call: IPCServer.defineRequest<MockableCallPayload, any>("mockable/call"),
+        spyResult: IPCServer.defineRequest<MockableSpyResultPayload, any>("mockable/spy-result"),
+    }
+}

package/src/mockable/GGMockableInterceptor.ts

@@ -1,44 +1,44 @@
-import type {GGTestRunner} from "../GGTestRunner";
-import {GGCallInterceptor, GGCallInterceptorConfig} from "../testers/GGCallInterceptor";
-import {GGMockableInterceptorsServer} from "./GGMockableInterceptorsServer";
-
-export interface MockableInterceptorConfig extends GGCallInterceptorConfig {
-    className: string;
-    methodName: string;
-}
-
-/**
- * Interceptor for mocking/spying on mockable class methods.
- * Registers with GGMockableInterceptorsServer which handles the IPC communication.
- *
- * For spy mode, the flow is two-phase:
- * 1. mockable/call → onRequest() validates input, returns undefined (CALL_THROUGH)
- * 2. mockable/spy-result → onResponse() validates output
- */
-export class GGMockableInterceptor extends GGCallInterceptor {
-
-    public readonly className: string;
-    public readonly methodName: string;
-
-    constructor(test: GGTestRunner, config: MockableInterceptorConfig) {
-        super(test, config);
-        this.className = config.className;
-        this.methodName = config.methodName;
-    }
-
-    public getKey(): string {
-        return `${this.className}.${this.methodName}`;
-    }
-
-    protected doRegister(): void {
-        this.test.getExtensionInstance(GGMockableInterceptorsServer).addInterceptor(this);
-    }
-
-    protected doUnregister(): void {
-        this.test.getExtensionInstance(GGMockableInterceptorsServer).deleteInterceptor(this);
-    }
-
-    protected parseResponseData(result: any): any {
-        return result;
-    }
-}
+import type {GGTestRunner} from "../GGTestRunner";
+import {GGCallInterceptor, GGCallInterceptorConfig} from "../testers/GGCallInterceptor";
+import {GGMockableInterceptorsServer} from "./GGMockableInterceptorsServer";
+
+export interface MockableInterceptorConfig extends GGCallInterceptorConfig {
+    className: string;
+    methodName: string;
+}
+
+/**
+ * Interceptor for mocking/spying on mockable class methods.
+ * Registers with GGMockableInterceptorsServer which handles the IPC communication.
+ *
+ * For spy mode, the flow is two-phase:
+ * 1. mockable/call → onRequest() validates input, returns undefined (CALL_THROUGH)
+ * 2. mockable/spy-result → onResponse() validates output
+ */
+export class GGMockableInterceptor extends GGCallInterceptor {
+
+    public readonly className: string;
+    public readonly methodName: string;
+
+    constructor(test: GGTestRunner, config: MockableInterceptorConfig) {
+        super(test, config);
+        this.className = config.className;
+        this.methodName = config.methodName;
+    }
+
+    public getKey(): string {
+        return `${this.className}.${this.methodName}`;
+    }
+
+    protected doRegister(): void {
+        this.test.getExtensionInstance(GGMockableInterceptorsServer).addInterceptor(this);
+    }
+
+    protected doUnregister(): void {
+        this.test.getExtensionInstance(GGMockableInterceptorsServer).deleteInterceptor(this);
+    }
+
+    protected parseResponseData(result: any): any {
+        return result;
+    }
+}