@git.zone/tstest 2.3.7 → 2.4.0

package/dist_ts/tstest.classes.runtime.bun.js

@@ -0,0 +1,184 @@
+import * as plugins from './tstest.plugins.js';
+import { coloredString as cs } from '@push.rocks/consolecolor';
+import { RuntimeAdapter, } from './tstest.classes.runtime.adapter.js';
+import { TapParser } from './tstest.classes.tap.parser.js';
+import { TsTestLogger } from './tstest.logging.js';
+/**
+ * Bun runtime adapter
+ * Executes tests using the Bun runtime with native TypeScript support
+ */
+export class BunRuntimeAdapter extends RuntimeAdapter {
+    constructor(logger, smartshellInstance, // SmartShell instance from @push.rocks/smartshell
+    timeoutSeconds, filterTags) {
+        super();
+        this.logger = logger;
+        this.smartshellInstance = smartshellInstance;
+        this.timeoutSeconds = timeoutSeconds;
+        this.filterTags = filterTags;
+        this.id = 'bun';
+        this.displayName = 'Bun';
+    }
+    /**
+     * Check if Bun is available
+     */
+    async checkAvailable() {
+        try {
+            const result = await this.smartshellInstance.exec('bun --version', {
+                cwd: process.cwd(),
+                onError: () => {
+                    // Ignore error
+                }
+            });
+            if (result.exitCode !== 0) {
+                return {
+                    available: false,
+                    error: 'Bun not found. Install from: https://bun.sh/',
+                };
+            }
+            // Bun version is just the version number
+            const version = result.stdout.trim();
+            return {
+                available: true,
+                version: `Bun ${version}`,
+            };
+        }
+        catch (error) {
+            return {
+                available: false,
+                error: error.message,
+            };
+        }
+    }
+    /**
+     * Create command configuration for Bun test execution
+     */
+    createCommand(testFile, options) {
+        const mergedOptions = this.mergeOptions(options);
+        const args = ['run'];
+        // Add extra args
+        if (mergedOptions.extraArgs && mergedOptions.extraArgs.length > 0) {
+            args.push(...mergedOptions.extraArgs);
+        }
+        // Add test file
+        args.push(testFile);
+        // Set environment variables
+        const env = { ...mergedOptions.env };
+        if (this.filterTags.length > 0) {
+            env.TSTEST_FILTER_TAGS = this.filterTags.join(',');
+        }
+        return {
+            command: 'bun',
+            args,
+            env,
+            cwd: mergedOptions.cwd,
+        };
+    }
+    /**
+     * Execute a test file in Bun
+     */
+    async run(testFile, index, total, options) {
+        this.logger.testFileStart(testFile, this.displayName, index, total);
+        const tapParser = new TapParser(testFile + ':bun', this.logger);
+        const mergedOptions = this.mergeOptions(options);
+        // Build Bun command
+        const command = this.createCommand(testFile, mergedOptions);
+        const fullCommand = `${command.command} ${command.args.join(' ')}`;
+        // Set filter tags as environment variable
+        if (this.filterTags.length > 0) {
+            process.env.TSTEST_FILTER_TAGS = this.filterTags.join(',');
+        }
+        // Check for 00init.ts file in test directory
+        const testDir = plugins.path.dirname(testFile);
+        const initFile = plugins.path.join(testDir, '00init.ts');
+        const initFileExists = await plugins.smartfile.fs.fileExists(initFile);
+        let runCommand = fullCommand;
+        let loaderPath = null;
+        // If 00init.ts exists, create a loader file
+        if (initFileExists) {
+            const absoluteInitFile = plugins.path.resolve(initFile);
+            const absoluteTestFile = plugins.path.resolve(testFile);
+            const loaderContent = `
+import '${absoluteInitFile.replace(/\\/g, '/')}';
+import '${absoluteTestFile.replace(/\\/g, '/')}';
+`;
+            loaderPath = plugins.path.join(testDir, `.loader_${plugins.path.basename(testFile)}`);
+            await plugins.smartfile.memory.toFs(loaderContent, loaderPath);
+            // Rebuild command with loader file
+            const loaderCommand = this.createCommand(loaderPath, mergedOptions);
+            runCommand = `${loaderCommand.command} ${loaderCommand.args.join(' ')}`;
+        }
+        const execResultStreaming = await this.smartshellInstance.execStreamingSilent(runCommand);
+        // If we created a loader file, clean it up after test execution
+        if (loaderPath) {
+            const cleanup = () => {
+                try {
+                    if (plugins.smartfile.fs.fileExistsSync(loaderPath)) {
+                        plugins.smartfile.fs.removeSync(loaderPath);
+                    }
+                }
+                catch (e) {
+                    // Ignore cleanup errors
+                }
+            };
+            execResultStreaming.childProcess.on('exit', cleanup);
+            execResultStreaming.childProcess.on('error', cleanup);
+        }
+        // Start warning timer if no timeout was specified
+        let warningTimer = null;
+        if (this.timeoutSeconds === null) {
+            warningTimer = setTimeout(() => {
+                console.error('');
+                console.error(cs('⚠️  WARNING: Test file is running for more than 1 minute', 'orange'));
+                console.error(cs(`   File: ${testFile}`, 'orange'));
+                console.error(cs('   Consider using --timeout option to set a timeout for test files.', 'orange'));
+                console.error(cs('   Example: tstest test --timeout=300 (for 5 minutes)', 'orange'));
+                console.error('');
+            }, 60000); // 1 minute
+        }
+        // Handle timeout if specified
+        if (this.timeoutSeconds !== null) {
+            const timeoutMs = this.timeoutSeconds * 1000;
+            let timeoutId;
+            const timeoutPromise = new Promise((_resolve, reject) => {
+                timeoutId = setTimeout(async () => {
+                    // Use smartshell's terminate() to kill entire process tree
+                    await execResultStreaming.terminate();
+                    reject(new Error(`Test file timed out after ${this.timeoutSeconds} seconds`));
+                }, timeoutMs);
+            });
+            try {
+                await Promise.race([
+                    tapParser.handleTapProcess(execResultStreaming.childProcess),
+                    timeoutPromise
+                ]);
+                // Clear timeout if test completed successfully
+                clearTimeout(timeoutId);
+            }
+            catch (error) {
+                // Clear warning timer if it was set
+                if (warningTimer) {
+                    clearTimeout(warningTimer);
+                }
+                // Handle timeout error
+                tapParser.handleTimeout(this.timeoutSeconds);
+                // Ensure entire process tree is killed if still running
+                try {
+                    await execResultStreaming.kill(); // This kills the entire process tree with SIGKILL
+                }
+                catch (killError) {
+                    // Process tree might already be dead
+                }
+                await tapParser.evaluateFinalResult();
+            }
+        }
+        else {
+            await tapParser.handleTapProcess(execResultStreaming.childProcess);
+        }
+        // Clear warning timer if it was set
+        if (warningTimer) {
+            clearTimeout(warningTimer);
+        }
+        return tapParser;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/tstest.classes.runtime.chromium.d.ts

@@ -0,0 +1,36 @@
+import { RuntimeAdapter, type ChromiumOptions, type RuntimeCommand, type RuntimeAvailability } from './tstest.classes.runtime.adapter.js';
+import { TapParser } from './tstest.classes.tap.parser.js';
+import { TsTestLogger } from './tstest.logging.js';
+import type { Runtime } from './tstest.classes.runtime.parser.js';
+/**
+ * Chromium runtime adapter
+ * Executes tests in a headless Chromium browser
+ */
+export declare class ChromiumRuntimeAdapter extends RuntimeAdapter {
+    private logger;
+    private tsbundleInstance;
+    private smartbrowserInstance;
+    private timeoutSeconds;
+    readonly id: Runtime;
+    readonly displayName: string;
+    constructor(logger: TsTestLogger, tsbundleInstance: any, // TsBundle instance from @push.rocks/tsbundle
+    smartbrowserInstance: any, // SmartBrowser instance from @push.rocks/smartbrowser
+    timeoutSeconds: number | null);
+    /**
+     * Check if Chromium is available
+     */
+    checkAvailable(): Promise<RuntimeAvailability>;
+    /**
+     * Create command configuration for Chromium test execution
+     * Note: Chromium tests don't use a traditional command, but this satisfies the interface
+     */
+    createCommand(testFile: string, options?: ChromiumOptions): RuntimeCommand;
+    /**
+     * Find free ports for HTTP server and WebSocket
+     */
+    private findFreePorts;
+    /**
+     * Execute a test file in Chromium browser
+     */
+    run(testFile: string, index: number, total: number, options?: ChromiumOptions): Promise<TapParser>;
+}

package/dist_ts/tstest.classes.runtime.chromium.js

@@ -0,0 +1,256 @@
+import * as plugins from './tstest.plugins.js';
+import * as paths from './tstest.paths.js';
+import { coloredString as cs } from '@push.rocks/consolecolor';
+import { RuntimeAdapter, } from './tstest.classes.runtime.adapter.js';
+import { TapParser } from './tstest.classes.tap.parser.js';
+import { TsTestLogger } from './tstest.logging.js';
+/**
+ * Chromium runtime adapter
+ * Executes tests in a headless Chromium browser
+ */
+export class ChromiumRuntimeAdapter extends RuntimeAdapter {
+    constructor(logger, tsbundleInstance, // TsBundle instance from @push.rocks/tsbundle
+    smartbrowserInstance, // SmartBrowser instance from @push.rocks/smartbrowser
+    timeoutSeconds) {
+        super();
+        this.logger = logger;
+        this.tsbundleInstance = tsbundleInstance;
+        this.smartbrowserInstance = smartbrowserInstance;
+        this.timeoutSeconds = timeoutSeconds;
+        this.id = 'chromium';
+        this.displayName = 'Chromium';
+    }
+    /**
+     * Check if Chromium is available
+     */
+    async checkAvailable() {
+        try {
+            // Check if smartbrowser is available and can start
+            // The browser binary is usually handled by @push.rocks/smartbrowser
+            return {
+                available: true,
+                version: 'Chromium (via smartbrowser)',
+            };
+        }
+        catch (error) {
+            return {
+                available: false,
+                error: error.message || 'Chromium not available',
+            };
+        }
+    }
+    /**
+     * Create command configuration for Chromium test execution
+     * Note: Chromium tests don't use a traditional command, but this satisfies the interface
+     */
+    createCommand(testFile, options) {
+        const mergedOptions = this.mergeOptions(options);
+        return {
+            command: 'chromium',
+            args: [],
+            env: mergedOptions.env,
+            cwd: mergedOptions.cwd,
+        };
+    }
+    /**
+     * Find free ports for HTTP server and WebSocket
+     */
+    async findFreePorts() {
+        const smartnetwork = new plugins.smartnetwork.SmartNetwork();
+        // Find random free HTTP port in range 30000-40000 to minimize collision chance
+        const httpPort = await smartnetwork.findFreePort(30000, 40000, { randomize: true });
+        if (!httpPort) {
+            throw new Error('Could not find a free HTTP port in range 30000-40000');
+        }
+        // Find random free WebSocket port, excluding the HTTP port to ensure they're different
+        const wsPort = await smartnetwork.findFreePort(30000, 40000, {
+            randomize: true,
+            exclude: [httpPort]
+        });
+        if (!wsPort) {
+            throw new Error('Could not find a free WebSocket port in range 30000-40000');
+        }
+        // Log selected ports for debugging
+        if (!this.logger.options.quiet) {
+            console.log(`Selected ports - HTTP: ${httpPort}, WebSocket: ${wsPort}`);
+        }
+        return { httpPort, wsPort };
+    }
+    /**
+     * Execute a test file in Chromium browser
+     */
+    async run(testFile, index, total, options) {
+        this.logger.testFileStart(testFile, this.displayName, index, total);
+        // lets get all our paths sorted
+        const tsbundleCacheDirPath = plugins.path.join(paths.cwd, './.nogit/tstest_cache');
+        const bundleFileName = testFile.replace('/', '__') + '.js';
+        const bundleFilePath = plugins.path.join(tsbundleCacheDirPath, bundleFileName);
+        // lets bundle the test
+        await plugins.smartfile.fs.ensureEmptyDir(tsbundleCacheDirPath);
+        await this.tsbundleInstance.build(process.cwd(), testFile, bundleFilePath, {
+            bundler: 'esbuild',
+        });
+        // Find free ports for HTTP and WebSocket
+        const { httpPort, wsPort } = await this.findFreePorts();
+        // lets create a server
+        const server = new plugins.typedserver.servertools.Server({
+            cors: true,
+            port: httpPort,
+        });
+        server.addRoute('/test', new plugins.typedserver.servertools.Handler('GET', async (_req, res) => {
+            res.type('.html');
+            res.write(`
+        <html>
+          <head>
+            <script>
+              globalThis.testdom = true;
+              globalThis.wsPort = ${wsPort};
+            </script>
+          </head>
+          <body></body>
+        </html>
+      `);
+            res.end();
+        }));
+        server.addRoute('/*splat', new plugins.typedserver.servertools.HandlerStatic(tsbundleCacheDirPath));
+        await server.start();
+        // lets handle realtime comms
+        const tapParser = new TapParser(testFile + ':chrome', this.logger);
+        const wss = new plugins.ws.WebSocketServer({ port: wsPort });
+        wss.on('connection', (ws) => {
+            ws.on('message', (message) => {
+                const messageStr = message.toString();
+                if (messageStr.startsWith('console:')) {
+                    const [, level, ...messageParts] = messageStr.split(':');
+                    this.logger.browserConsole(messageParts.join(':'), level);
+                }
+                else {
+                    tapParser.handleTapLog(messageStr);
+                }
+            });
+        });
+        // lets do the browser bit with timeout handling
+        await this.smartbrowserInstance.start();
+        const evaluatePromise = this.smartbrowserInstance.evaluateOnPage(`http://localhost:${httpPort}/test?bundleName=${bundleFileName}`, async () => {
+            // lets enable real time comms
+            const ws = new WebSocket(`ws://localhost:${globalThis.wsPort}`);
+            await new Promise((resolve) => (ws.onopen = resolve));
+            // Ensure this function is declared with 'async'
+            const logStore = [];
+            const originalLog = console.log;
+            const originalError = console.error;
+            // Override console methods to capture the logs
+            console.log = (...args) => {
+                logStore.push(args.join(' '));
+                ws.send(args.join(' '));
+                originalLog(...args);
+            };
+            console.error = (...args) => {
+                logStore.push(args.join(' '));
+                ws.send(args.join(' '));
+                originalError(...args);
+            };
+            const bundleName = new URLSearchParams(window.location.search).get('bundleName');
+            originalLog(`::TSTEST IN CHROMIUM:: Relevant Script name is: ${bundleName}`);
+            try {
+                // Dynamically import the test module
+                const testModule = await import(`/${bundleName}`);
+                if (testModule && testModule.default && testModule.default instanceof Promise) {
+                    // Execute the exported test function
+                    await testModule.default;
+                }
+                else if (testModule && testModule.default && typeof testModule.default.then === 'function') {
+                    console.log('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!');
+                    console.log('Test module default export is just promiselike: Something might be messing with your Promise implementation.');
+                    console.log('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!');
+                    await testModule.default;
+                }
+                else if (globalThis.tapPromise && typeof globalThis.tapPromise.then === 'function') {
+                    console.log('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!');
+                    console.log('Using globalThis.tapPromise');
+                    console.log('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!');
+                    await testModule.default;
+                }
+                else {
+                    console.error('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!');
+                    console.error('Test module does not export a default promise.');
+                    console.error('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!');
+                    console.log(`We got: ${JSON.stringify(testModule)}`);
+                }
+            }
+            catch (err) {
+                console.error(err);
+            }
+            return logStore.join('\n');
+        });
+        // Start warning timer if no timeout was specified
+        let warningTimer = null;
+        if (this.timeoutSeconds === null) {
+            warningTimer = setTimeout(() => {
+                console.error('');
+                console.error(cs('⚠️  WARNING: Test file is running for more than 1 minute', 'orange'));
+                console.error(cs(`   File: ${testFile}`, 'orange'));
+                console.error(cs('   Consider using --timeout option to set a timeout for test files.', 'orange'));
+                console.error(cs('   Example: tstest test --timeout=300 (for 5 minutes)', 'orange'));
+                console.error('');
+            }, 60000); // 1 minute
+        }
+        // Handle timeout if specified
+        if (this.timeoutSeconds !== null) {
+            const timeoutMs = this.timeoutSeconds * 1000;
+            let timeoutId;
+            const timeoutPromise = new Promise((_resolve, reject) => {
+                timeoutId = setTimeout(() => {
+                    reject(new Error(`Test file timed out after ${this.timeoutSeconds} seconds`));
+                }, timeoutMs);
+            });
+            try {
+                await Promise.race([
+                    evaluatePromise,
+                    timeoutPromise
+                ]);
+                // Clear timeout if test completed successfully
+                clearTimeout(timeoutId);
+            }
+            catch (error) {
+                // Clear warning timer if it was set
+                if (warningTimer) {
+                    clearTimeout(warningTimer);
+                }
+                // Handle timeout error
+                tapParser.handleTimeout(this.timeoutSeconds);
+            }
+        }
+        else {
+            await evaluatePromise;
+        }
+        // Clear warning timer if it was set
+        if (warningTimer) {
+            clearTimeout(warningTimer);
+        }
+        // Always clean up resources, even on timeout
+        try {
+            await this.smartbrowserInstance.stop();
+        }
+        catch (error) {
+            // Browser might already be stopped
+        }
+        try {
+            await server.stop();
+        }
+        catch (error) {
+            // Server might already be stopped
+        }
+        try {
+            wss.close();
+        }
+        catch (error) {
+            // WebSocket server might already be closed
+        }
+        console.log(`${cs('=> ', 'blue')} Stopped ${cs(testFile, 'orange')} chromium instance and server.`);
+        // Always evaluate final result (handleTimeout just sets up the test state)
+        await tapParser.evaluateFinalResult();
+        return tapParser;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tstest.classes.runtime.chromium.js","sourceRoot":"","sources":["../ts/tstest.classes.runtime.chromium.ts"],"names":[],"mappings":"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"}

package/dist_ts/tstest.classes.runtime.deno.d.ts

@@ -0,0 +1,34 @@
+import { RuntimeAdapter, type DenoOptions, type RuntimeCommand, type RuntimeAvailability } from './tstest.classes.runtime.adapter.js';
+import { TapParser } from './tstest.classes.tap.parser.js';
+import { TsTestLogger } from './tstest.logging.js';
+import type { Runtime } from './tstest.classes.runtime.parser.js';
+/**
+ * Deno runtime adapter
+ * Executes tests using the Deno runtime
+ */
+export declare class DenoRuntimeAdapter extends RuntimeAdapter {
+    private logger;
+    private smartshellInstance;
+    private timeoutSeconds;
+    private filterTags;
+    readonly id: Runtime;
+    readonly displayName: string;
+    constructor(logger: TsTestLogger, smartshellInstance: any, // SmartShell instance from @push.rocks/smartshell
+    timeoutSeconds: number | null, filterTags: string[]);
+    /**
+     * Get default Deno options
+     */
+    protected getDefaultOptions(): DenoOptions;
+    /**
+     * Check if Deno is available
+     */
+    checkAvailable(): Promise<RuntimeAvailability>;
+    /**
+     * Create command configuration for Deno test execution
+     */
+    createCommand(testFile: string, options?: DenoOptions): RuntimeCommand;
+    /**
+     * Execute a test file in Deno
+     */
+    run(testFile: string, index: number, total: number, options?: DenoOptions): Promise<TapParser>;
+}