@git.zone/tstest 2.3.8 → 2.4.0

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

@@ -0,0 +1,205 @@
+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';
+/**
+ * Deno runtime adapter
+ * Executes tests using the Deno runtime
+ */
+export class DenoRuntimeAdapter 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 = 'deno';
+        this.displayName = 'Deno';
+    }
+    /**
+     * Get default Deno options
+     */
+    getDefaultOptions() {
+        return {
+            ...super.getDefaultOptions(),
+            permissions: ['--allow-read', '--allow-env'],
+        };
+    }
+    /**
+     * Check if Deno is available
+     */
+    async checkAvailable() {
+        try {
+            const result = await this.smartshellInstance.exec('deno --version', {
+                cwd: process.cwd(),
+                onError: () => {
+                    // Ignore error
+                }
+            });
+            if (result.exitCode !== 0) {
+                return {
+                    available: false,
+                    error: 'Deno not found. Install from: https://deno.land/',
+                };
+            }
+            // Parse Deno version from output (first line is "deno X.Y.Z")
+            const versionMatch = result.stdout.match(/deno (\d+\.\d+\.\d+)/);
+            const version = versionMatch ? versionMatch[1] : 'unknown';
+            return {
+                available: true,
+                version: `Deno ${version}`,
+            };
+        }
+        catch (error) {
+            return {
+                available: false,
+                error: error.message,
+            };
+        }
+    }
+    /**
+     * Create command configuration for Deno test execution
+     */
+    createCommand(testFile, options) {
+        const mergedOptions = this.mergeOptions(options);
+        const args = ['run'];
+        // Add permissions
+        const permissions = mergedOptions.permissions || ['--allow-read', '--allow-env'];
+        args.push(...permissions);
+        // Add config file if specified
+        if (mergedOptions.configPath) {
+            args.push('--config', mergedOptions.configPath);
+        }
+        // Add import map if specified
+        if (mergedOptions.importMap) {
+            args.push('--import-map', mergedOptions.importMap);
+        }
+        // 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: 'deno',
+            args,
+            env,
+            cwd: mergedOptions.cwd,
+        };
+    }
+    /**
+     * Execute a test file in Deno
+     */
+    async run(testFile, index, total, options) {
+        this.logger.testFileStart(testFile, this.displayName, index, total);
+        const tapParser = new TapParser(testFile + ':deno', this.logger);
+        const mergedOptions = this.mergeOptions(options);
+        // Build Deno 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,{"version":3,"file":"tstest.classes.runtime.deno.js","sourceRoot":"","sources":["../ts/tstest.classes.runtime.deno.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,30 @@
+import { RuntimeAdapter, type RuntimeOptions, 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';
+/**
+ * Node.js runtime adapter
+ * Executes tests using tsrun (TypeScript runner for Node.js)
+ */
+export declare class NodeRuntimeAdapter 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[]);
+    /**
+     * Check if Node.js and tsrun are available
+     */
+    checkAvailable(): Promise<RuntimeAvailability>;
+    /**
+     * Create command configuration for Node.js test execution
+     */
+    createCommand(testFile: string, options?: RuntimeOptions): RuntimeCommand;
+    /**
+     * Execute a test file in Node.js
+     */
+    run(testFile: string, index: number, total: number, options?: RuntimeOptions): Promise<TapParser>;
+}

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

@@ -0,0 +1,188 @@
+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';
+/**
+ * Node.js runtime adapter
+ * Executes tests using tsrun (TypeScript runner for Node.js)
+ */
+export class NodeRuntimeAdapter 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 = 'node';
+        this.displayName = 'Node.js';
+    }
+    /**
+     * Check if Node.js and tsrun are available
+     */
+    async checkAvailable() {
+        try {
+            // Check Node.js version
+            const nodeVersion = process.version;
+            // Check if tsrun is available
+            const result = await this.smartshellInstance.exec('tsrun --version', {
+                cwd: process.cwd(),
+                onError: () => {
+                    // Ignore error
+                }
+            });
+            if (result.exitCode !== 0) {
+                return {
+                    available: false,
+                    error: 'tsrun not found. Install with: pnpm install --save-dev @git.zone/tsrun',
+                };
+            }
+            return {
+                available: true,
+                version: nodeVersion,
+            };
+        }
+        catch (error) {
+            return {
+                available: false,
+                error: error.message,
+            };
+        }
+    }
+    /**
+     * Create command configuration for Node.js test execution
+     */
+    createCommand(testFile, options) {
+        const mergedOptions = this.mergeOptions(options);
+        // Build tsrun options
+        const args = [];
+        if (process.argv.includes('--web')) {
+            args.push('--web');
+        }
+        // Add any extra args
+        if (mergedOptions.extraArgs) {
+            args.push(...mergedOptions.extraArgs);
+        }
+        // Set environment variables
+        const env = { ...mergedOptions.env };
+        if (this.filterTags.length > 0) {
+            env.TSTEST_FILTER_TAGS = this.filterTags.join(',');
+        }
+        return {
+            command: 'tsrun',
+            args: [testFile, ...args],
+            env,
+            cwd: mergedOptions.cwd,
+        };
+    }
+    /**
+     * Execute a test file in Node.js
+     */
+    async run(testFile, index, total, options) {
+        this.logger.testFileStart(testFile, this.displayName, index, total);
+        const tapParser = new TapParser(testFile + ':node', this.logger);
+        const mergedOptions = this.mergeOptions(options);
+        // Build tsrun command
+        let tsrunOptions = '';
+        if (process.argv.includes('--web')) {
+            tsrunOptions += ' --web';
+        }
+        // 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');
+        let runCommand = `tsrun ${testFile}${tsrunOptions}`;
+        const initFileExists = await plugins.smartfile.fs.fileExists(initFile);
+        // If 00init.ts exists, run it first
+        let loaderPath = null;
+        if (initFileExists) {
+            // Create a temporary loader file that imports both 00init.ts and the test file
+            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);
+            runCommand = `tsrun ${loaderPath}${tsrunOptions}`;
+        }
+        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.parser.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Runtime parser for test file naming convention
+ * Supports: test.runtime1+runtime2.modifier.ts
+ * Examples:
+ *   - test.node.ts
+ *   - test.chromium.ts
+ *   - test.node+chromium.ts
+ *   - test.deno+bun.ts
+ *   - test.chromium.nonci.ts
+ */
+export type Runtime = 'node' | 'chromium' | 'deno' | 'bun';
+export type Modifier = 'nonci';
+export interface ParsedFilename {
+    baseName: string;
+    runtimes: Runtime[];
+    modifiers: Modifier[];
+    extension: string;
+    isLegacy: boolean;
+    original: string;
+}
+export interface ParserConfig {
+    strictUnknownRuntime?: boolean;
+    defaultRuntimes?: Runtime[];
+}
+/**
+ * Parse a test filename to extract runtimes, modifiers, and detect legacy patterns
+ * Algorithm: Right-to-left token analysis from the extension
+ */
+export declare function parseTestFilename(filePath: string, config?: ParserConfig): ParsedFilename;
+/**
+ * Check if a filename uses legacy naming convention
+ */
+export declare function isLegacyFilename(fileName: string): boolean;
+/**
+ * Get the suggested new filename for a legacy filename
+ */
+export declare function getLegacyMigrationTarget(fileName: string): string | null;

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

@@ -0,0 +1,159 @@
+/**
+ * Runtime parser for test file naming convention
+ * Supports: test.runtime1+runtime2.modifier.ts
+ * Examples:
+ *   - test.node.ts
+ *   - test.chromium.ts
+ *   - test.node+chromium.ts
+ *   - test.deno+bun.ts
+ *   - test.chromium.nonci.ts
+ */
+const KNOWN_RUNTIMES = new Set(['node', 'chromium', 'deno', 'bun']);
+const KNOWN_MODIFIERS = new Set(['nonci']);
+const VALID_EXTENSIONS = new Set(['ts', 'tsx', 'mts', 'cts']);
+// Legacy mappings for backwards compatibility
+const LEGACY_RUNTIME_MAP = {
+    browser: ['chromium'],
+    both: ['node', 'chromium'],
+};
+/**
+ * Parse a test filename to extract runtimes, modifiers, and detect legacy patterns
+ * Algorithm: Right-to-left token analysis from the extension
+ */
+export function parseTestFilename(filePath, config = {}) {
+    const strictUnknownRuntime = config.strictUnknownRuntime ?? true;
+    const defaultRuntimes = config.defaultRuntimes ?? ['node'];
+    // Extract just the filename from the path
+    const fileName = filePath.split('/').pop() || filePath;
+    const original = fileName;
+    // Step 1: Extract and validate extension
+    const lastDot = fileName.lastIndexOf('.');
+    if (lastDot === -1) {
+        throw new Error(`Invalid test file: no extension found in "${fileName}"`);
+    }
+    const extension = fileName.substring(lastDot + 1);
+    if (!VALID_EXTENSIONS.has(extension)) {
+        throw new Error(`Invalid test file extension ".${extension}" in "${fileName}". ` +
+            `Valid extensions: ${Array.from(VALID_EXTENSIONS).join(', ')}`);
+    }
+    // Step 2: Split remaining basename by dots
+    const withoutExtension = fileName.substring(0, lastDot);
+    const tokens = withoutExtension.split('.');
+    if (tokens.length === 0) {
+        throw new Error(`Invalid test file: empty basename in "${fileName}"`);
+    }
+    // Step 3: Parse from right to left
+    let isLegacy = false;
+    const modifiers = [];
+    let runtimes = [];
+    let runtimeTokenIndex = -1;
+    // Scan from right to left
+    for (let i = tokens.length - 1; i >= 0; i--) {
+        const token = tokens[i];
+        // Check if this is a known modifier
+        if (KNOWN_MODIFIERS.has(token)) {
+            modifiers.unshift(token);
+            continue;
+        }
+        // Check if this is a legacy runtime token
+        if (LEGACY_RUNTIME_MAP[token]) {
+            isLegacy = true;
+            runtimes = LEGACY_RUNTIME_MAP[token];
+            runtimeTokenIndex = i;
+            break;
+        }
+        // Check if this is a runtime chain (may contain + separators)
+        if (token.includes('+')) {
+            const runtimeCandidates = token.split('+').map(r => r.trim()).filter(Boolean);
+            const validRuntimes = [];
+            const invalidRuntimes = [];
+            for (const candidate of runtimeCandidates) {
+                if (KNOWN_RUNTIMES.has(candidate)) {
+                    // Dedupe: only add if not already in list
+                    if (!validRuntimes.includes(candidate)) {
+                        validRuntimes.push(candidate);
+                    }
+                }
+                else {
+                    invalidRuntimes.push(candidate);
+                }
+            }
+            if (invalidRuntimes.length > 0) {
+                if (strictUnknownRuntime) {
+                    throw new Error(`Unknown runtime(s) in "${fileName}": ${invalidRuntimes.join(', ')}. ` +
+                        `Valid runtimes: ${Array.from(KNOWN_RUNTIMES).join(', ')}`);
+                }
+                else {
+                    console.warn(`⚠️  Warning: Unknown runtime(s) in "${fileName}": ${invalidRuntimes.join(', ')}. ` +
+                        `Defaulting to: ${defaultRuntimes.join('+')}`);
+                    runtimes = [...defaultRuntimes];
+                    runtimeTokenIndex = i;
+                    break;
+                }
+            }
+            if (validRuntimes.length > 0) {
+                runtimes = validRuntimes;
+                runtimeTokenIndex = i;
+                break;
+            }
+        }
+        // Check if this is a single runtime token
+        if (KNOWN_RUNTIMES.has(token)) {
+            runtimes = [token];
+            runtimeTokenIndex = i;
+            break;
+        }
+        // If we've scanned past modifiers and haven't found a runtime, stop looking
+        if (modifiers.length > 0) {
+            break;
+        }
+    }
+    // Step 4: Determine base name
+    // Everything before the runtime token (if found) is the base name
+    const baseNameTokens = runtimeTokenIndex >= 0 ? tokens.slice(0, runtimeTokenIndex) : tokens;
+    const baseName = baseNameTokens.join('.');
+    // Step 5: Apply defaults if no runtime was detected
+    if (runtimes.length === 0) {
+        runtimes = [...defaultRuntimes];
+    }
+    return {
+        baseName: baseName || 'test',
+        runtimes,
+        modifiers,
+        extension,
+        isLegacy,
+        original,
+    };
+}
+/**
+ * Check if a filename uses legacy naming convention
+ */
+export function isLegacyFilename(fileName) {
+    const tokens = fileName.split('.');
+    for (const token of tokens) {
+        if (LEGACY_RUNTIME_MAP[token]) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Get the suggested new filename for a legacy filename
+ */
+export function getLegacyMigrationTarget(fileName) {
+    const parsed = parseTestFilename(fileName, { strictUnknownRuntime: false });
+    if (!parsed.isLegacy) {
+        return null;
+    }
+    // Reconstruct filename with new naming
+    const parts = [parsed.baseName];
+    if (parsed.runtimes.length > 0) {
+        parts.push(parsed.runtimes.join('+'));
+    }
+    if (parsed.modifiers.length > 0) {
+        parts.push(...parsed.modifiers);
+    }
+    parts.push(parsed.extension);
+    return parts.join('.');
+}
+//# sourceMappingURL=data:application/json;base64,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