@grest-ts/testkit 0.0.6 → 0.0.8

package/src/callOn/GGCallOnSelector.ts

@@ -1,61 +1,61 @@
-/**
- * Selector extension that adds targeted callOn to selectors.
- *
- * This allows explicitly targeting specific runtimes when multiple
- * different runtime classes have the same service registered.
- *
- * @example
- * const f = GGTest.startWorker({chain: ChainRuntime, weather: WeatherOnlyRuntime});
- *
- * // Both have WeatherService - explicitly target one:
- * await f.chain.callOn(WeatherService).getWeather("Test").toMatchObject({...})
- * await f.weather.callOn(WeatherService).getWeather("Test").toMatchObject({...})
- */
-
-import {GGContext} from "@grest-ts/context";
-import {GGTestSelector, GGTestSelectorExtension} from "../testers/GGTestSelector";
-import {RuntimeConstructor} from "../testers/RuntimeSelector";
-import {callOnTargeted, GGTestCallOn} from "./callOn";
-import type {GGTestRuntime} from "../GGTestRuntime";
-
-/**
- * Type for the callable callOn extension.
- * Can be called as a function to invoke targeted callOn.
- */
-export interface GGCallOnSelectorCallable {
-    <T>(target: T, ctx?: GGContext): GGTestCallOn<T>;
-}
-
-/**
- * Extension that adds .callOn() as a callable to Selectors.
- * Uses the selector's runtimes to target specific instances.
- *
- * Returns a callable that can be used directly: f.chain.callOn(WeatherService)
- */
-export class GGCallOnSelector extends GGTestSelectorExtension {
-
-    public static readonly PROPERTY_NAME = "callOn";
-
-    constructor(runtimes: GGTestRuntime[]) {
-        super(runtimes);
-        // Return a callable function instead of this instance
-        const callable = <T>(target: T, ctx?: GGContext): GGTestCallOn<T> => {
-            return callOnTargeted(target, runtimes, ctx);
-        };
-        return callable as unknown as this;
-    }
-}
-
-// Declaration merging to add 'callOn' to SelectorExtensions
-declare module "@grest-ts/testkit" {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    interface SelectorExtensions<T extends RuntimeConstructor[]> {
-        callOn: GGCallOnSelectorCallable;
-    }
-}
-
-// Ensure RuntimeConstructor import is recognized (for declaration merging above)
-export type _RuntimeConstructorRef = RuntimeConstructor;
-
-// Register the extension
-GGTestSelector.addExtension(GGCallOnSelector);
+/**
+ * Selector extension that adds targeted callOn to selectors.
+ *
+ * This allows explicitly targeting specific runtimes when multiple
+ * different runtime classes have the same service registered.
+ *
+ * @example
+ * const f = GGTest.startWorker({chain: ChainRuntime, weather: WeatherOnlyRuntime});
+ *
+ * // Both have WeatherService - explicitly target one:
+ * await f.chain.callOn(WeatherService).getWeather("Test").toMatchObject({...})
+ * await f.weather.callOn(WeatherService).getWeather("Test").toMatchObject({...})
+ */
+
+import {GGContext} from "@grest-ts/context";
+import {GGTestSelector, GGTestSelectorExtension} from "../testers/GGTestSelector";
+import {RuntimeConstructor} from "../testers/RuntimeSelector";
+import {callOnTargeted, GGTestCallOn} from "./callOn";
+import type {GGTestRuntime} from "../GGTestRuntime";
+
+/**
+ * Type for the callable callOn extension.
+ * Can be called as a function to invoke targeted callOn.
+ */
+export interface GGCallOnSelectorCallable {
+    <T>(target: T, ctx?: GGContext): GGTestCallOn<T>;
+}
+
+/**
+ * Extension that adds .callOn() as a callable to Selectors.
+ * Uses the selector's runtimes to target specific instances.
+ *
+ * Returns a callable that can be used directly: f.chain.callOn(WeatherService)
+ */
+export class GGCallOnSelector extends GGTestSelectorExtension {
+
+    public static readonly PROPERTY_NAME = "callOn";
+
+    constructor(runtimes: GGTestRuntime[]) {
+        super(runtimes);
+        // Return a callable function instead of this instance
+        const callable = <T>(target: T, ctx?: GGContext): GGTestCallOn<T> => {
+            return callOnTargeted(target, runtimes, ctx);
+        };
+        return callable as unknown as this;
+    }
+}
+
+// Declaration merging to add 'callOn' to SelectorExtensions
+declare module "@grest-ts/testkit" {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    interface SelectorExtensions<T extends RuntimeConstructor[]> {
+        callOn: GGCallOnSelectorCallable;
+    }
+}
+
+// Ensure RuntimeConstructor import is recognized (for declaration merging above)
+export type _RuntimeConstructorRef = RuntimeConstructor;
+
+// Register the extension
+GGTestSelector.addExtension(GGCallOnSelector);

package/src/callOn/GGContractClass.implement.ts

@@ -1,43 +1,43 @@
-/**
- * Patches GGContractClass.implement() to auto-register contract instances in GGLocator.
- *
- * This enables callOn(ContractClass) to work without each protocol (HTTP, WebSocket, etc.)
- * needing to manually register the contract instance.
- */
-
-import {GGContractClass} from "@grest-ts/schema";
-import {GGLocator, GGLocatorKey} from "@grest-ts/locator";
-
-// Store the original implement method
-const originalImplement = GGContractClass.prototype.implement;
-
-export const LOCATOR_KEY_PREFIX_FOR_CONTRACT = "@contract:"
-
-/**
- * Patched implement() that registers the returned client in GGLocator.
- */
-GGContractClass.prototype.implement = function (
-    this: GGContractClass<any>,
-    instance: any,
-    options?: any
-) {
-    const contractName = this.name;
-
-    // Get the client from original implement
-    const client = originalImplement.call(this, instance, options);
-
-    // Register in GGLocator for callOn(Contract) access
-    const scope = GGLocator.tryGetScope();
-    if (scope) {
-        const key = new GGLocatorKey<typeof client>(LOCATOR_KEY_PREFIX_FOR_CONTRACT + contractName);
-        if (scope.has(key)) {
-            throw new Error(
-                `Contract '${contractName}' is already registered in this scope. ` +
-                `If you need multiple instances, use different contract names.`
-            );
-        }
-        scope.set(key, client);
-    }
-
-    return client;
-};
+/**
+ * Patches GGContractClass.implement() to auto-register contract instances in GGLocator.
+ *
+ * This enables callOn(ContractClass) to work without each protocol (HTTP, WebSocket, etc.)
+ * needing to manually register the contract instance.
+ */
+
+import {GGContractClass} from "@grest-ts/schema";
+import {GGLocator, GGLocatorKey} from "@grest-ts/locator";
+
+// Store the original implement method
+const originalImplement = GGContractClass.prototype.implement;
+
+export const LOCATOR_KEY_PREFIX_FOR_CONTRACT = "@contract:"
+
+/**
+ * Patched implement() that registers the returned client in GGLocator.
+ */
+GGContractClass.prototype.implement = function (
+    this: GGContractClass<any>,
+    instance: any,
+    options?: any
+) {
+    const contractName = this.name;
+
+    // Get the client from original implement
+    const client = originalImplement.call(this, instance, options);
+
+    // Register in GGLocator for callOn(Contract) access
+    const scope = GGLocator.tryGetScope();
+    if (scope) {
+        const key = new GGLocatorKey<typeof client>(LOCATOR_KEY_PREFIX_FOR_CONTRACT + contractName);
+        if (scope.has(key)) {
+            throw new Error(
+                `Contract '${contractName}' is already registered in this scope. ` +
+                `If you need multiple instances, use different contract names.`
+            );
+        }
+        scope.set(key, client);
+    }
+
+    return client;
+};

package/src/callOn/GGTestActionForLocatorOnCall.ts

@@ -1,134 +1,134 @@
-/**
- * Test action for invoking methods via GGLocator lookup.
- *
- * Used for:
- * - @testable services (key: @testable:ClassName)
- * - Direct contract calls (key: @contract:ContractName)
- * - Custom GGLocatorKey lookups
- *
- * Extends GGTestAction to support .with() for mocks/spies and
- * response expectations like .toMatchObject(), .toEqual().
- */
-
-import {GGTestAction, GGTestActionConfig, tActionRawData} from "../testers/GGTestAction";
-import {GG_TEST_RUNNER} from "../GGTestRunner";
-import {SerializedContext, TestableInvokeResult, TestableIPC} from "./TestableIPC";
-import {GGTestError} from "../utils/GGTestError";
-import {GGContext} from "@grest-ts/context";
-import type {GGTestRuntime} from "../GGTestRuntime";
-
-/**
- * Serialize a GGContext to a plain object for IPC transfer.
- * Flattens the context hierarchy into a single object.
- */
-function serializeContext(ctx: GGContext): SerializedContext {
-    const result: SerializedContext = {};
-    // Access the private values map via type assertion
-    const ctxAny = ctx as any;
-    if (ctxAny.values instanceof Map) {
-        for (const [key, value] of ctxAny.values) {
-            result[key] = value;
-        }
-    }
-    // Also serialize parent context values (child values take precedence)
-    if (ctxAny.parent) {
-        const parentValues = serializeContext(ctxAny.parent);
-        return {...parentValues, ...result};
-    }
-    return result;
-}
-
-/**
- * Action for invoking a method via GGLocator lookup over IPC.
- *
- * @typeParam T - The expected return type of the method
- */
-export class GGTestActionForLocatorOnCall<T> extends GGTestAction<T> {
-
-    private readonly keyName: string;
-    private readonly methodName: string;
-    private readonly args: any[];
-    private readonly targetRuntimes?: GGTestRuntime[];
-
-    constructor(ctx: GGContext, keyName: string, methodName: string, args: any[], targetRuntimes?: GGTestRuntime[]) {
-        const config: GGTestActionConfig = {
-            noResponse: false,
-            logData: {
-                message: `[${keyName}.${methodName}]`,
-                request: args.length > 0 ? args : undefined
-            }
-        };
-        super(ctx, config);
-        this.keyName = keyName;
-        this.methodName = methodName;
-        this.args = args;
-        this.targetRuntimes = targetRuntimes;
-    }
-
-    // -------------------------------------------------
-    // Action execution
-    // -------------------------------------------------
-
-    protected async executeAction(): Promise<tActionRawData> {
-        const runner = GG_TEST_RUNNER.get();
-
-        // Use target runtimes if provided, otherwise all runtimes
-        const searchRuntimes = this.targetRuntimes ?? runner.getAllRuntimes();
-
-        // Find runtimes that have this key registered
-        const candidates = searchRuntimes.filter(r => r.hasLocatorKey(this.keyName));
-
-        if (candidates.length === 0) {
-            // No runtime has this key - provide helpful error
-            const allRuntimes = runner.getAllRuntimes();
-            if (allRuntimes.length === 0) {
-                throw new GGTestError({
-                    test: `No runtimes available to invoke ${this.keyName}.${this.methodName}`,
-                    expected: "At least one runtime to be started",
-                    received: "No runtimes found"
-                });
-            }
-            throw new GGTestError({
-                test: `Instance '${this.keyName}' not found in any runtime`,
-                expected: `A @testable instance registered with key '${this.keyName}'`,
-                received: `Key not registered in any of ${allRuntimes.length} runtime(s): ${allRuntimes.map(r => r.name).join(', ')}`
-            });
-        }
-
-        if (candidates.length > 1) {
-            // Check if all candidates are the same runtime class - if so, just use first one
-            const uniqueClassNames = new Set(candidates.map(r => r.className));
-            if (uniqueClassNames.size > 1) {
-                // Different runtime classes have this key - actual ambiguity
-                throw new GGTestError({
-                    test: `Multiple different runtimes have '${this.keyName}' registered`,
-                    expected: `Key '${this.keyName}' to be unique across different runtime classes, or use explicit runtime targeting`,
-                    received: `Found in ${candidates.length} runtimes with different classes: ${[...uniqueClassNames].join(', ')}`
-                });
-            }
-            // Same runtime class - just use first instance (they're identical)
-        }
-
-        // Exactly one runtime has this key - send IPC directly
-        const runtime = candidates[0];
-        const context = this.ctx ? serializeContext(this.ctx) : undefined;
-
-        const result: TestableInvokeResult = await runtime.sendCommand(TestableIPC.invoke, {
-            keyName: this.keyName,
-            methodName: this.methodName,
-            args: this.args,
-            context
-        });
-
-        if (result.success) {
-            return result.result as tActionRawData;
-        }
-
-        throw new GGTestError({
-            test: `Error invoking ${this.keyName}.${this.methodName}`,
-            expected: "Method to execute successfully",
-            received: result.error || "Unknown error",
-            extra: result.stack
-        });
-    }
-}
+/**
+ * Test action for invoking methods via GGLocator lookup.
+ *
+ * Used for:
+ * - @testable services (key: @testable:ClassName)
+ * - Direct contract calls (key: @contract:ContractName)
+ * - Custom GGLocatorKey lookups
+ *
+ * Extends GGTestAction to support .with() for mocks/spies and
+ * response expectations like .toMatchObject(), .toEqual().
+ */
+
+import {GGTestAction, GGTestActionConfig, tActionRawData} from "../testers/GGTestAction";
+import {GG_TEST_RUNNER} from "../GGTestRunner";
+import {SerializedContext, TestableInvokeResult, TestableIPC} from "./TestableIPC";
+import {GGTestError} from "../utils/GGTestError";
+import {GGContext} from "@grest-ts/context";
+import type {GGTestRuntime} from "../GGTestRuntime";
+
+/**
+ * Serialize a GGContext to a plain object for IPC transfer.
+ * Flattens the context hierarchy into a single object.
+ */
+function serializeContext(ctx: GGContext): SerializedContext {
+    const result: SerializedContext = {};
+    // Access the private values map via type assertion
+    const ctxAny = ctx as any;
+    if (ctxAny.values instanceof Map) {
+        for (const [key, value] of ctxAny.values) {
+            result[key] = value;
+        }
+    }
+    // Also serialize parent context values (child values take precedence)
+    if (ctxAny.parent) {
+        const parentValues = serializeContext(ctxAny.parent);
+        return {...parentValues, ...result};
+    }
+    return result;
+}
+
+/**
+ * Action for invoking a method via GGLocator lookup over IPC.
+ *
+ * @typeParam T - The expected return type of the method
+ */
+export class GGTestActionForLocatorOnCall<T> extends GGTestAction<T> {
+
+    private readonly keyName: string;
+    private readonly methodName: string;
+    private readonly args: any[];
+    private readonly targetRuntimes?: GGTestRuntime[];
+
+    constructor(ctx: GGContext, keyName: string, methodName: string, args: any[], targetRuntimes?: GGTestRuntime[]) {
+        const config: GGTestActionConfig = {
+            noResponse: false,
+            logData: {
+                message: `[${keyName}.${methodName}]`,
+                request: args.length > 0 ? args : undefined
+            }
+        };
+        super(ctx, config);
+        this.keyName = keyName;
+        this.methodName = methodName;
+        this.args = args;
+        this.targetRuntimes = targetRuntimes;
+    }
+
+    // -------------------------------------------------
+    // Action execution
+    // -------------------------------------------------
+
+    protected async executeAction(): Promise<tActionRawData> {
+        const runner = GG_TEST_RUNNER.get();
+
+        // Use target runtimes if provided, otherwise all runtimes
+        const searchRuntimes = this.targetRuntimes ?? runner.getAllRuntimes();
+
+        // Find runtimes that have this key registered
+        const candidates = searchRuntimes.filter(r => r.hasLocatorKey(this.keyName));
+
+        if (candidates.length === 0) {
+            // No runtime has this key - provide helpful error
+            const allRuntimes = runner.getAllRuntimes();
+            if (allRuntimes.length === 0) {
+                throw new GGTestError({
+                    test: `No runtimes available to invoke ${this.keyName}.${this.methodName}`,
+                    expected: "At least one runtime to be started",
+                    received: "No runtimes found"
+                });
+            }
+            throw new GGTestError({
+                test: `Instance '${this.keyName}' not found in any runtime`,
+                expected: `A @testable instance registered with key '${this.keyName}'`,
+                received: `Key not registered in any of ${allRuntimes.length} runtime(s): ${allRuntimes.map(r => r.name).join(', ')}`
+            });
+        }
+
+        if (candidates.length > 1) {
+            // Check if all candidates are the same runtime class - if so, just use first one
+            const uniqueClassNames = new Set(candidates.map(r => r.className));
+            if (uniqueClassNames.size > 1) {
+                // Different runtime classes have this key - actual ambiguity
+                throw new GGTestError({
+                    test: `Multiple different runtimes have '${this.keyName}' registered`,
+                    expected: `Key '${this.keyName}' to be unique across different runtime classes, or use explicit runtime targeting`,
+                    received: `Found in ${candidates.length} runtimes with different classes: ${[...uniqueClassNames].join(', ')}`
+                });
+            }
+            // Same runtime class - just use first instance (they're identical)
+        }
+
+        // Exactly one runtime has this key - send IPC directly
+        const runtime = candidates[0];
+        const context = this.ctx ? serializeContext(this.ctx) : undefined;
+
+        const result: TestableInvokeResult = await runtime.sendCommand(TestableIPC.invoke, {
+            keyName: this.keyName,
+            methodName: this.methodName,
+            args: this.args,
+            context
+        });
+
+        if (result.success) {
+            return result.result as tActionRawData;
+        }
+
+        throw new GGTestError({
+            test: `Error invoking ${this.keyName}.${this.methodName}`,
+            expected: "Method to execute successfully",
+            received: result.error || "Unknown error",
+            extra: result.stack
+        });
+    }
+}

package/src/callOn/TestableIPC.ts

@@ -1,81 +1,81 @@
-/**
- * IPC protocol definitions for GGLocator-based service invocation.
- *
- * Defines the messages exchanged between test runner and runtime worker
- * for invoking methods on registered instances (@testable, @contract, etc.).
- */
-
-import {IPCClient, IPCServer} from "@grest-ts/ipc";
-
-/**
- * Serialized context data for IPC transfer.
- * Contains flattened key-value pairs from GGContext.
- */
-export type SerializedContext = Record<string, any>;
-
-/**
- * Payload for invoking a method on a registered instance.
- */
-export interface TestableInvokePayload {
-    /** The GGLocatorKey name (e.g., "@testable:ServiceB", "@contract:ChainApi", or custom key) */
-    keyName: string;
-    /** The method name to invoke */
-    methodName: string;
-    /** Arguments to pass to the method (as array) */
-    args: any[];
-    /** Serialized GGContext data to restore on the worker side */
-    context?: SerializedContext;
-}
-
-/**
- * Result from invoking a testable method.
- */
-export interface TestableInvokeResult {
-    /** Whether the invocation succeeded */
-    success: boolean;
-    /** The return value from the method (if success) */
-    result?: any;
-    /** Error message (if failed) */
-    error?: string;
-    /** Error stack trace (if failed) */
-    stack?: string;
-}
-
-/**
- * Payload for registering locator keys from a runtime.
- */
-export interface KeyRegistrationPayload {
-    /** Runtime ID sending the registration */
-    runtimeId: string;
-    /** All GGLocatorKey names registered in this runtime */
-    keys: string[];
-}
-
-/**
- * IPC endpoints for testable service invocation.
- */
-export const TestableIPC = {
-    /**
-     * Messages FROM test server TO worker.
-     */
-    client: {
-        /**
-         * Invoke a method on a testable service instance.
-         */
-        invoke: IPCClient.defineRequest<TestableInvokePayload, TestableInvokeResult>("testable/invoke"),
-    },
-
-    /**
-     * Messages FROM worker TO test server.
-     */
-    server: {
-        /**
-         * Register all locator keys available in a runtime.
-         * Sent from worker to test runner after compose completes.
-         */
-        registerKeys: IPCServer.defineRequest<KeyRegistrationPayload, void>("testable/register-keys"),
-    },
-
-    // Legacy alias for backwards compatibility
-    invoke: IPCClient.defineRequest<TestableInvokePayload, TestableInvokeResult>("testable/invoke"),
-};
+/**
+ * IPC protocol definitions for GGLocator-based service invocation.
+ *
+ * Defines the messages exchanged between test runner and runtime worker
+ * for invoking methods on registered instances (@testable, @contract, etc.).
+ */
+
+import {IPCClient, IPCServer} from "@grest-ts/ipc";
+
+/**
+ * Serialized context data for IPC transfer.
+ * Contains flattened key-value pairs from GGContext.
+ */
+export type SerializedContext = Record<string, any>;
+
+/**
+ * Payload for invoking a method on a registered instance.
+ */
+export interface TestableInvokePayload {
+    /** The GGLocatorKey name (e.g., "@testable:ServiceB", "@contract:ChainApi", or custom key) */
+    keyName: string;
+    /** The method name to invoke */
+    methodName: string;
+    /** Arguments to pass to the method (as array) */
+    args: any[];
+    /** Serialized GGContext data to restore on the worker side */
+    context?: SerializedContext;
+}
+
+/**
+ * Result from invoking a testable method.
+ */
+export interface TestableInvokeResult {
+    /** Whether the invocation succeeded */
+    success: boolean;
+    /** The return value from the method (if success) */
+    result?: any;
+    /** Error message (if failed) */
+    error?: string;
+    /** Error stack trace (if failed) */
+    stack?: string;
+}
+
+/**
+ * Payload for registering locator keys from a runtime.
+ */
+export interface KeyRegistrationPayload {
+    /** Runtime ID sending the registration */
+    runtimeId: string;
+    /** All GGLocatorKey names registered in this runtime */
+    keys: string[];
+}
+
+/**
+ * IPC endpoints for testable service invocation.
+ */
+export const TestableIPC = {
+    /**
+     * Messages FROM test server TO worker.
+     */
+    client: {
+        /**
+         * Invoke a method on a testable service instance.
+         */
+        invoke: IPCClient.defineRequest<TestableInvokePayload, TestableInvokeResult>("testable/invoke"),
+    },
+
+    /**
+     * Messages FROM worker TO test server.
+     */
+    server: {
+        /**
+         * Register all locator keys available in a runtime.
+         * Sent from worker to test runner after compose completes.
+         */
+        registerKeys: IPCServer.defineRequest<KeyRegistrationPayload, void>("testable/register-keys"),
+    },
+
+    // Legacy alias for backwards compatibility
+    invoke: IPCClient.defineRequest<TestableInvokePayload, TestableInvokeResult>("testable/invoke"),
+};