@grest-ts/testkit 0.0.6 → 0.0.8

package/src/runner/WorkerRunner.ts

@@ -1,179 +1,179 @@
-import type {RuntimeRunner} from "./RuntimeRunner";
-import {Worker} from "worker_threads";
-import {GGLog} from "@grest-ts/logger";
-import {GGTestEnvConfig} from "../GGTestRuntime";
-
-export class WorkerRunner implements RuntimeRunner {
-    private worker?: Worker;
-
-    private static workerLoaderPath: string | undefined;
-
-    /**
-     * Set the path to the worker-loader.mjs file.
-     * Called by @grest-ts/testkit-vitest to inject the path.
-     */
-    public static setWorkerLoaderPath(path: string): void {
-        this.workerLoaderPath = path;
-    }
-
-    constructor(private readonly config: GGTestEnvConfig) {
-    }
-
-    async start(): Promise<void> {
-        GGLog.debug(this, 'Starting worker: ' + this.config.executablePath);
-
-        if (!WorkerRunner.workerLoaderPath) {
-            throw new Error(
-                "Worker loader path not set!\n" +
-                "Make sure to import '@grest-ts/testkit-vitest' in your vitest setup."
-            );
-        }
-        const workerLoaderPath = WorkerRunner.workerLoaderPath;
-
-        this.worker = new Worker(workerLoaderPath, {
-            workerData: this.config,
-            stdout: true,
-            stderr: true
-        });
-
-        // Forward worker stdout to parent's console using console.log
-        // so vitest can capture and sequence it properly with test output
-        this.worker.stdout.on('data', (data: Buffer) => {
-            const str = data.toString();
-            // Split by newlines and log each line (trimming trailing newline)
-            const lines = str.split('\n');
-            for (const line of lines) {
-                if (line) console.log(line);
-            }
-        });
-
-        // Forward worker stderr to parent's console
-        this.worker.stderr.on('data', (data: Buffer) => {
-            const str = data.toString();
-            const lines = str.split('\n');
-            for (const line of lines) {
-                if (line) console.error(line);
-            }
-        });
-
-        // Wait for worker to signal ready
-        try {
-            await new Promise<void>((resolve, reject) => {
-                if (!this.worker) {
-                    reject(new Error('Worker failed to start'));
-                    return;
-                }
-
-                const timeout = setTimeout(() => {
-                    // CRITICAL: Terminate worker on timeout to prevent leak
-                    this.worker?.terminate();
-                    reject(new Error('Worker did not start within 10 seconds'));
-                }, 10000);
-
-                const messageHandler = (msg: any) => {
-                    if (msg.type === 'ready') {
-                        clearTimeout(timeout);
-                        this.worker?.off('message', messageHandler);
-                        // Monitor for unexpected worker exit after successful startup
-                        this.worker?.on('exit', (code) => {
-                            GGLog.error(this, `Worker exited unexpectedly with code ${code}`);
-                        });
-                        GGLog.debug(this, 'Worker ready');
-                        resolve();
-                    } else if (msg.type === 'error') {
-                        clearTimeout(timeout);
-                        this.worker?.off('message', messageHandler);
-                        this.worker?.terminate();
-                        reject(new Error(`Runtime worker startup failed! ${msg.error}`));
-                    }
-                };
-
-                this.worker.on('message', messageHandler);
-
-                this.worker.once('error', (err) => {
-                    clearTimeout(timeout);
-                    this.worker?.terminate();
-                    reject(err);
-                });
-
-                this.worker.once('exit', (code) => {
-                    if (code !== 0) {
-                        clearTimeout(timeout);
-                        reject(new Error(`Worker exited with code ${code}`));
-                    }
-                });
-            });
-        } catch (error) {
-            // Ensure worker is cleaned up on any error
-            this.worker = undefined;
-            throw error;
-        }
-    }
-
-    async stopRuntime(): Promise<void> {
-        if (!this.worker) {
-            return;
-        }
-
-        GGLog.debug(this, 'Stopping runtime in worker...');
-
-        return new Promise<void>((resolve, reject) => {
-            if (!this.worker) {
-                resolve();
-                return;
-            }
-
-            const timeout = setTimeout(() => {
-                GGLog.error(this, 'Timeout waiting for runtime to stop');
-                reject(new Error('Timeout waiting for runtime to stop'));
-            }, 5000);
-
-            const messageHandler = (msg: any) => {
-                if (msg.type === 'runtimeStopped') {
-                    clearTimeout(timeout);
-                    this.worker?.off('message', messageHandler);
-                    GGLog.debug(this, 'Runtime stopped in worker');
-                    resolve();
-                }
-            };
-
-            this.worker.on('message', messageHandler);
-            this.worker.postMessage({type: 'stopRuntime'});
-        });
-    }
-
-    async shutdown(): Promise<void> {
-        if (!this.worker) {
-            return;
-        }
-
-        GGLog.debug(this, 'Shutting down worker...');
-
-        return new Promise<void>((resolve) => {
-            if (!this.worker) {
-                resolve();
-                return;
-            }
-
-            this.worker.once('exit', () => {
-                clearTimeout(forceTerminateTimeout);
-                this.worker = undefined;
-                GGLog.debug(this, 'Worker shut down');
-                resolve();
-            });
-
-            // Send shutdown message for graceful shutdown
-            this.worker.postMessage({type: 'shutdown'});
-
-            // Force terminate after 2 seconds if graceful shutdown doesn't work
-            const forceTerminateTimeout = setTimeout(() => {
-                if (this.worker) {
-                    GGLog.debug(this, 'Force terminating worker (timeout)');
-                    this.worker.terminate();
-                    this.worker = undefined;
-                    resolve();
-                }
-            }, 2000);
-        });
-    }
-}
+import type {RuntimeRunner} from "./RuntimeRunner";
+import {Worker} from "worker_threads";
+import {GGLog} from "@grest-ts/logger";
+import {GGTestEnvConfig} from "../GGTestRuntime";
+
+export class WorkerRunner implements RuntimeRunner {
+    private worker?: Worker;
+
+    private static workerLoaderPath: string | undefined;
+
+    /**
+     * Set the path to the worker-loader.mjs file.
+     * Called by @grest-ts/testkit-vitest to inject the path.
+     */
+    public static setWorkerLoaderPath(path: string): void {
+        this.workerLoaderPath = path;
+    }
+
+    constructor(private readonly config: GGTestEnvConfig) {
+    }
+
+    async start(): Promise<void> {
+        GGLog.debug(this, 'Starting worker: ' + this.config.executablePath);
+
+        if (!WorkerRunner.workerLoaderPath) {
+            throw new Error(
+                "Worker loader path not set!\n" +
+                "Make sure to import '@grest-ts/testkit-vitest' in your vitest setup."
+            );
+        }
+        const workerLoaderPath = WorkerRunner.workerLoaderPath;
+
+        this.worker = new Worker(workerLoaderPath, {
+            workerData: this.config,
+            stdout: true,
+            stderr: true
+        });
+
+        // Forward worker stdout to parent's console using console.log
+        // so vitest can capture and sequence it properly with test output
+        this.worker.stdout.on('data', (data: Buffer) => {
+            const str = data.toString();
+            // Split by newlines and log each line (trimming trailing newline)
+            const lines = str.split('\n');
+            for (const line of lines) {
+                if (line) console.log(line);
+            }
+        });
+
+        // Forward worker stderr to parent's console
+        this.worker.stderr.on('data', (data: Buffer) => {
+            const str = data.toString();
+            const lines = str.split('\n');
+            for (const line of lines) {
+                if (line) console.error(line);
+            }
+        });
+
+        // Wait for worker to signal ready
+        try {
+            await new Promise<void>((resolve, reject) => {
+                if (!this.worker) {
+                    reject(new Error('Worker failed to start'));
+                    return;
+                }
+
+                const timeout = setTimeout(() => {
+                    // CRITICAL: Terminate worker on timeout to prevent leak
+                    this.worker?.terminate();
+                    reject(new Error('Worker did not start within 10 seconds'));
+                }, 10000);
+
+                const messageHandler = (msg: any) => {
+                    if (msg.type === 'ready') {
+                        clearTimeout(timeout);
+                        this.worker?.off('message', messageHandler);
+                        // Monitor for unexpected worker exit after successful startup
+                        this.worker?.on('exit', (code) => {
+                            GGLog.error(this, `Worker exited unexpectedly with code ${code}`);
+                        });
+                        GGLog.debug(this, 'Worker ready');
+                        resolve();
+                    } else if (msg.type === 'error') {
+                        clearTimeout(timeout);
+                        this.worker?.off('message', messageHandler);
+                        this.worker?.terminate();
+                        reject(new Error(`Runtime worker startup failed! ${msg.error}`));
+                    }
+                };
+
+                this.worker.on('message', messageHandler);
+
+                this.worker.once('error', (err) => {
+                    clearTimeout(timeout);
+                    this.worker?.terminate();
+                    reject(err);
+                });
+
+                this.worker.once('exit', (code) => {
+                    if (code !== 0) {
+                        clearTimeout(timeout);
+                        reject(new Error(`Worker exited with code ${code}`));
+                    }
+                });
+            });
+        } catch (error) {
+            // Ensure worker is cleaned up on any error
+            this.worker = undefined;
+            throw error;
+        }
+    }
+
+    async stopRuntime(): Promise<void> {
+        if (!this.worker) {
+            return;
+        }
+
+        GGLog.debug(this, 'Stopping runtime in worker...');
+
+        return new Promise<void>((resolve, reject) => {
+            if (!this.worker) {
+                resolve();
+                return;
+            }
+
+            const timeout = setTimeout(() => {
+                GGLog.error(this, 'Timeout waiting for runtime to stop');
+                reject(new Error('Timeout waiting for runtime to stop'));
+            }, 5000);
+
+            const messageHandler = (msg: any) => {
+                if (msg.type === 'runtimeStopped') {
+                    clearTimeout(timeout);
+                    this.worker?.off('message', messageHandler);
+                    GGLog.debug(this, 'Runtime stopped in worker');
+                    resolve();
+                }
+            };
+
+            this.worker.on('message', messageHandler);
+            this.worker.postMessage({type: 'stopRuntime'});
+        });
+    }
+
+    async shutdown(): Promise<void> {
+        if (!this.worker) {
+            return;
+        }
+
+        GGLog.debug(this, 'Shutting down worker...');
+
+        return new Promise<void>((resolve) => {
+            if (!this.worker) {
+                resolve();
+                return;
+            }
+
+            this.worker.once('exit', () => {
+                clearTimeout(forceTerminateTimeout);
+                this.worker = undefined;
+                GGLog.debug(this, 'Worker shut down');
+                resolve();
+            });
+
+            // Send shutdown message for graceful shutdown
+            this.worker.postMessage({type: 'shutdown'});
+
+            // Force terminate after 2 seconds if graceful shutdown doesn't work
+            const forceTerminateTimeout = setTimeout(() => {
+                if (this.worker) {
+                    GGLog.debug(this, 'Force terminating worker (timeout)');
+                    this.worker.terminate();
+                    this.worker = undefined;
+                    resolve();
+                }
+            }, 2000);
+        });
+    }
+}

package/src/runner/isolated-loader.mjs

@@ -1,91 +1,91 @@
-/**
- * Isolated process loader for ES modules
- * This file is the entry point for isolated test processes
- *
- * Usage: npx tsx isolated-loader.mjs <runtime-source-url>
- * Environment: GG_ISOLATED_CONFIG must be set with JSON config
- */
-import {register} from 'tsx/esm/api';
-import {pathToFileURL} from 'url';
-
-// Register tsx to handle TypeScript with ESM
-register();
-
-// Get the runtime source URL from command line args (can be file:// URL or path)
-let runtimeSourceUrl = process.argv[2];
-if (!runtimeSourceUrl) {
-    console.error('Usage: npx tsx isolated-loader.mjs <runtime-source-url>');
-    process.exit(1);
-}
-
-// Convert to file:// URL if it's a path
-if (!runtimeSourceUrl.startsWith('file:')) {
-    runtimeSourceUrl = pathToFileURL(runtimeSourceUrl).href;
-}
-
-const GG_ISOLATED_CONFIG = "GG_ISOLATED_CONFIG";
-const PROCESS_READY = "IsolatedRunner:READY";
-
-// Get config from environment
-const configJson = process.env[GG_ISOLATED_CONFIG];
-if (!configJson) {
-    console.error('GG_ISOLATED_CONFIG not set');
-    process.exit(1);
-}
-
-// Import runtime and testkit dependencies
-const {GGRuntime} = await import('@grest-ts/runtime');
-const {GGTestRuntimeWorker} = await import('@grest-ts/testkit');
-const {GGLog} = await import('@grest-ts/logger');
-
-const config = JSON.parse(configJson);
-
-// Override cli() to intercept runtime startup in isolated mode
-
-GGRuntime.cli = async function(moduleUrl) {
-    // Still set SOURCE_MODULE_URL for testkit compatibility
-    this.SOURCE_MODULE_URL = moduleUrl;
-
-    // Start the runtime via test worker instead of normal startup
-    const controlClient = new GGTestRuntimeWorker(config);
-
-    try {
-        await controlClient.start(() => new this());
-
-        // Signal to parent process that we're ready
-        console.log(PROCESS_READY);
-
-        const stopRuntime = async () => {
-            // Stop the GGRuntime but keep process alive for log retrieval
-            await controlClient.stopRuntime();
-            console.log('IsolatedRunner:RUNTIME_STOPPED');
-        };
-
-        const shutdown = async () => {
-            // Fully shutdown process
-            await controlClient.shutdown();
-            process.exit(0);
-        };
-
-        // Listen for commands via stdin
-        process.stdin.setEncoding('utf8');
-        process.stdin.on('data', (data) => {
-            const message = data.toString().trim();
-            if (message === 'STOP_RUNTIME') {
-                GGLog.debug({name: 'IsolatedLoader'}, 'Received stop runtime command');
-                stopRuntime();
-            } else if (message === 'SHUTDOWN') {
-                GGLog.debug({name: 'IsolatedLoader'}, 'Received shutdown command');
-                shutdown();
-            }
-        });
-        process.on('SIGTERM', shutdown);
-        process.on('SIGINT', shutdown);
-    } catch (err) {
-        GGLog.error({name: 'IsolatedLoader'}, 'Failed to start isolated runtime', err);
-        process.exit(1);
-    }
-};
-
-// Import the runtime source - this will call the overridden cli()
-await import(runtimeSourceUrl);
+/**
+ * Isolated process loader for ES modules
+ * This file is the entry point for isolated test processes
+ *
+ * Usage: npx tsx isolated-loader.mjs <runtime-source-url>
+ * Environment: GG_ISOLATED_CONFIG must be set with JSON config
+ */
+import {register} from 'tsx/esm/api';
+import {pathToFileURL} from 'url';
+
+// Register tsx to handle TypeScript with ESM
+register();
+
+// Get the runtime source URL from command line args (can be file:// URL or path)
+let runtimeSourceUrl = process.argv[2];
+if (!runtimeSourceUrl) {
+    console.error('Usage: npx tsx isolated-loader.mjs <runtime-source-url>');
+    process.exit(1);
+}
+
+// Convert to file:// URL if it's a path
+if (!runtimeSourceUrl.startsWith('file:')) {
+    runtimeSourceUrl = pathToFileURL(runtimeSourceUrl).href;
+}
+
+const GG_ISOLATED_CONFIG = "GG_ISOLATED_CONFIG";
+const PROCESS_READY = "IsolatedRunner:READY";
+
+// Get config from environment
+const configJson = process.env[GG_ISOLATED_CONFIG];
+if (!configJson) {
+    console.error('GG_ISOLATED_CONFIG not set');
+    process.exit(1);
+}
+
+// Import runtime and testkit dependencies
+const {GGRuntime} = await import('@grest-ts/runtime');
+const {GGTestRuntimeWorker} = await import('@grest-ts/testkit');
+const {GGLog} = await import('@grest-ts/logger');
+
+const config = JSON.parse(configJson);
+
+// Override cli() to intercept runtime startup in isolated mode
+
+GGRuntime.cli = async function(moduleUrl) {
+    // Still set SOURCE_MODULE_URL for testkit compatibility
+    this.SOURCE_MODULE_URL = moduleUrl;
+
+    // Start the runtime via test worker instead of normal startup
+    const controlClient = new GGTestRuntimeWorker(config);
+
+    try {
+        await controlClient.start(() => new this());
+
+        // Signal to parent process that we're ready
+        console.log(PROCESS_READY);
+
+        const stopRuntime = async () => {
+            // Stop the GGRuntime but keep process alive for log retrieval
+            await controlClient.stopRuntime();
+            console.log('IsolatedRunner:RUNTIME_STOPPED');
+        };
+
+        const shutdown = async () => {
+            // Fully shutdown process
+            await controlClient.shutdown();
+            process.exit(0);
+        };
+
+        // Listen for commands via stdin
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (data) => {
+            const message = data.toString().trim();
+            if (message === 'STOP_RUNTIME') {
+                GGLog.debug({name: 'IsolatedLoader'}, 'Received stop runtime command');
+                stopRuntime();
+            } else if (message === 'SHUTDOWN') {
+                GGLog.debug({name: 'IsolatedLoader'}, 'Received shutdown command');
+                shutdown();
+            }
+        });
+        process.on('SIGTERM', shutdown);
+        process.on('SIGINT', shutdown);
+    } catch (err) {
+        GGLog.error({name: 'IsolatedLoader'}, 'Failed to start isolated runtime', err);
+        process.exit(1);
+    }
+};
+
+// Import the runtime source - this will call the overridden cli()
+await import(runtimeSourceUrl);

package/src/runner/worker-loader.mjs

@@ -1,49 +1,49 @@
-/**
- * Worker loader for ES modules
- * This file is loaded by worker threads to execute test runtimes
- *
- * workerData is GGTestEnvConfig: { executablePath, testRouterPort, testId, runtimeId, initialCommands }
- */
-import {register} from 'tsx/esm/api';
-import {parentPort, workerData} from 'worker_threads';
-
-// Register tsx to handle TypeScript with ESM
-register();
-
-// Catch unhandled errors in worker thread
-process.on('uncaughtException', (err) => {
-    console.error(`[WorkerThread ${workerData?.runtimeId}] Uncaught exception:`, err);
-});
-process.on('unhandledRejection', (reason) => {
-    console.error(`[WorkerThread ${workerData?.runtimeId}] Unhandled rejection:`, reason);
-});
-
-// workerData is GGTestEnvConfig directly
-const config = workerData;
-
-// Import control client from @grest-ts/testkit
-const {GGTestRuntimeWorker} = await import('@grest-ts/testkit');
-
-// Create control client
-const controlClient = new GGTestRuntimeWorker(config);
-
-// Start the runtime
-try {
-    await controlClient.start();
-    parentPort.postMessage({type: 'ready'});
-} catch (err) {
-    parentPort.postMessage({type: 'error', error: err.stack || err.message});
-}
-
-// Handle messages from parent
-parentPort.on('message', async (msg) => {
-    if (msg.type === 'stopRuntime') {
-        // Stop the GGRuntime but keep worker alive for log retrieval
-        await controlClient.stopRuntime();
-        parentPort.postMessage({type: 'runtimeStopped'});
-    } else if (msg.type === 'shutdown') {
-        // Fully shutdown worker
-        await controlClient.shutdown();
-        process.exit(0);
-    }
-});
+/**
+ * Worker loader for ES modules
+ * This file is loaded by worker threads to execute test runtimes
+ *
+ * workerData is GGTestEnvConfig: { executablePath, testRouterPort, testId, runtimeId, initialCommands }
+ */
+import {register} from 'tsx/esm/api';
+import {parentPort, workerData} from 'worker_threads';
+
+// Register tsx to handle TypeScript with ESM
+register();
+
+// Catch unhandled errors in worker thread
+process.on('uncaughtException', (err) => {
+    console.error(`[WorkerThread ${workerData?.runtimeId}] Uncaught exception:`, err);
+});
+process.on('unhandledRejection', (reason) => {
+    console.error(`[WorkerThread ${workerData?.runtimeId}] Unhandled rejection:`, reason);
+});
+
+// workerData is GGTestEnvConfig directly
+const config = workerData;
+
+// Import control client from @grest-ts/testkit
+const {GGTestRuntimeWorker} = await import('@grest-ts/testkit');
+
+// Create control client
+const controlClient = new GGTestRuntimeWorker(config);
+
+// Start the runtime
+try {
+    await controlClient.start();
+    parentPort.postMessage({type: 'ready'});
+} catch (err) {
+    parentPort.postMessage({type: 'error', error: err.stack || err.message});
+}
+
+// Handle messages from parent
+parentPort.on('message', async (msg) => {
+    if (msg.type === 'stopRuntime') {
+        // Stop the GGRuntime but keep worker alive for log retrieval
+        await controlClient.stopRuntime();
+        parentPort.postMessage({type: 'runtimeStopped'});
+    } else if (msg.type === 'shutdown') {
+        // Fully shutdown worker
+        await controlClient.shutdown();
+        process.exit(0);
+    }
+});