@git.zone/tstest 4.1.1 → 5.0.0

package/ts/tstest.classes.runtime.docker.ts

@@ -139,7 +139,8 @@ export class DockerRuntimeAdapter extends RuntimeAdapter {
     total: number,
     options?: RuntimeOptions
   ): Promise<TapParser> {
-    this.logger.testFileStart(testFile, this.displayName, index, total);
+    const logger = this.logger.createTestFileLogger();
+    logger.testFileStart(testFile, this.displayName, index, total);
 
     // Parse the Docker test filename
     const parsed = parseDockerTestFilename(testFile);
@@ -158,7 +159,7 @@ export class DockerRuntimeAdapter extends RuntimeAdapter {
     const relativeTestPath = plugins.path.relative(this.cwd, absoluteTestPath);
 
     // Create TAP parser
-    const tapParser = new TapParser(testFile + ':docker', this.logger);
+    const tapParser = new TapParser(testFile + ':docker', logger);
 
     try {
       // Build docker run command
@@ -172,7 +173,7 @@ export class DockerRuntimeAdapter extends RuntimeAdapter {
         `/test/${plugins.path.basename(testFile)}`
       ];
 
-      this.logger.tapOutput(`Executing: docker ${dockerArgs.join(' ')}`);
+      logger.tapOutput(`Executing: docker ${dockerArgs.join(' ')}`);
 
       // Execute the Docker container
       const execPromise = this.smartshellInstance.execStreaming(
@@ -186,7 +187,7 @@ export class DockerRuntimeAdapter extends RuntimeAdapter {
       let timeoutHandle: NodeJS.Timeout | null = null;
       if (this.timeoutSeconds) {
         timeoutHandle = setTimeout(() => {
-          this.logger.tapOutput(`⏱️  Test timeout (${this.timeoutSeconds}s) - killing container`);
+          logger.tapOutput(`⏱️  Test timeout (${this.timeoutSeconds}s) - killing container`);
           // Try to kill any running containers with this image
           this.smartshellInstance.exec(`docker ps -q --filter ancestor=${imageName} | xargs -r docker kill`);
         }, this.timeoutSeconds * 1000);
@@ -205,7 +206,7 @@ export class DockerRuntimeAdapter extends RuntimeAdapter {
 
       execPromise.childProcess.stderr.on('data', (data: Buffer) => {
         const output = data.toString();
-        this.logger.tapOutput(cs(`[stderr] ${output}`, 'orange'));
+        logger.tapOutput(cs(`[stderr] ${output}`, 'orange'));
       });
 
       // Wait for completion
@@ -217,16 +218,14 @@ export class DockerRuntimeAdapter extends RuntimeAdapter {
       }
 
       if (result.exitCode !== 0) {
-        this.logger.tapOutput(cs(`❌ Docker test failed with exit code ${result.exitCode}`, 'red'));
+        tapParser.handleExecutionError(`Docker test failed with exit code ${result.exitCode}`);
       }
 
       // Evaluate final result
       await tapParser.evaluateFinalResult();
 
     } catch (error) {
-      this.logger.tapOutput(cs(`❌ Error running Docker test: ${error.message}`, 'red'));
-      // Add a failing test result to the parser
-      tapParser.handleTapLog('not ok 1 - Docker test execution failed');
+      tapParser.handleExecutionError(`Error running Docker test: ${error.message}`);
       await tapParser.evaluateFinalResult();
     }
 

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

@@ -97,8 +97,9 @@ export class NodeRuntimeAdapter extends RuntimeAdapter {
     total: number,
     options?: RuntimeOptions
   ): Promise<TapParser> {
-    this.logger.testFileStart(testFile, this.displayName, index, total);
-    const tapParser = new TapParser(testFile + ':node', this.logger);
+    const logger = this.logger.createTestFileLogger();
+    logger.testFileStart(testFile, this.displayName, index, total);
+    const tapParser = new TapParser(testFile + ':node', logger);
 
     const mergedOptions = this.mergeOptions(options);
 
@@ -145,6 +146,10 @@ import '${absoluteTestFile.replace(/\\/g, '/')}';
     // Spawn the test process using tsrun's spawnPath API
     // Pass undefined for fromFileUrl since fileToRun is already an absolute path
     const tsrunProcess = plugins.tsrun.spawnPath(fileToRun, undefined, spawnOptions);
+    // The parser owns the outcome; also observe tsrun's rejected spawn/signal promise.
+    void tsrunProcess.exitCode.catch((errorArg: Error) => {
+      tapParser.handleExecutionError(errorArg.message);
+    });
 
     // If we created a loader file, clean it up after test execution
     if (loaderPath) {

package/ts/tstest.classes.tap.combinator.ts

@@ -32,9 +32,7 @@ export class TapCombinator {
     // Check for failures
     let failGlobal = false;
     for (const tapParser of this.tapParserStore) {
-      if (!tapParser.expectedTests || 
-          tapParser.expectedTests !== tapParser.receivedTests || 
-          tapParser.getErrorTests().length > 0) {
+      if (tapParser.failed) {
         failGlobal = true;
         break;
       }

package/ts/tstest.classes.tap.parser.ts

@@ -16,6 +16,17 @@ export class TapParser {
 
   expectedTests: number = 0;
   receivedTests: number = 0;
+  public readonly executionErrors: string[] = [];
+  private finalized = false;
+
+  public get failed(): boolean {
+    return this.executionErrors.length > 0 || !this.expectedTests ||
+      this.expectedTests !== this.receivedTests || this.getErrorTests().length > 0;
+  }
+
+  public handleExecutionError(messageArg: string): void {
+    if (!this.executionErrors.includes(messageArg)) this.executionErrors.push(messageArg);
+  }
 
   activeTapTestResult: TapTestResult;
 
@@ -38,30 +49,7 @@ export class TapParser {
    * Handle test file timeout
    */
   public handleTimeout(timeoutSeconds: number) {
-    // If no tests have been defined yet, set expected to 1
-    if (this.expectedTests === 0) {
-      this.expectedTests = 1;
-    }
-    
-    // Create a fake failing test result for timeout
-    this._getNewTapTestResult();
-    this.activeTapTestResult.testOk = false;
-    this.activeTapTestResult.testSettled = true;
-    this.testStore.push(this.activeTapTestResult);
-    
-    // Log the timeout error
-    if (this.logger) {
-      // First log the test result
-      this.logger.testResult(
-        `Test file timeout`,
-        false,
-        timeoutSeconds * 1000,
-        `Error: Test file exceeded timeout of ${timeoutSeconds} seconds`
-      );
-      this.logger.testErrorDetails(`Test execution was terminated after ${timeoutSeconds} seconds`);
-    }
-    
-    // Don't call evaluateFinalResult here, let the caller handle it
+    this.handleExecutionError(`Test file exceeded timeout of ${timeoutSeconds} seconds`);
   }
 
   private _getNewTapTestResult() {
@@ -259,9 +247,7 @@ export class TapParser {
         break;
         
       case 'bailout':
-        if (this.logger) {
-          this.logger.error(`Bail out! ${message.content}`);
-        }
+        this.handleExecutionError(`Bail out! ${message.content}`);
         break;
         
       case 'error':
@@ -466,24 +452,32 @@ export class TapParser {
    * handles a tap process
    * @param childProcessArg
    */
-  public async handleTapProcess(childProcessArg: ChildProcess) {
-    const done = plugins.smartpromise.defer();
-    childProcessArg.stdout.on('data', (data) => {
-      this._processLog(data);
-    });
-    childProcessArg.stderr.on('data', (data) => {
-      this._processLog(data);
-    });
-    childProcessArg.on('exit', async () => {
-      // Flush any remaining buffered content
-      if (this.lineBuffer) {
-        this._handleConsoleOutput(this.lineBuffer, false);
-        this.lineBuffer = '';
-      }
-      await this.evaluateFinalResult();
-      done.resolve();
+  public async handleTapProcess(childProcessArg: ChildProcess, finalizeArg = true) {
+    await new Promise<void>((resolve) => {
+      const onData = (dataArg: Buffer) => this._processLog(dataArg);
+      const onError = (errorArg: Error) => this.handleExecutionError(errorArg.message);
+      childProcessArg.stdout?.on('data', onData);
+      childProcessArg.stderr?.on('data', onData);
+      childProcessArg.on('error', onError);
+      // close follows both process exit and pipe drainage, including failed spawn.
+      childProcessArg.once('close', (codeArg, signalArg) => {
+        childProcessArg.stdout?.off('data', onData);
+        childProcessArg.stderr?.off('data', onData);
+        childProcessArg.off('error', onError);
+        if (codeArg !== 0) {
+          this.handleExecutionError(signalArg
+            ? `Test process terminated by ${signalArg}`
+            : `Test process exited with code ${codeArg}`);
+        }
+        if (this.lineBuffer) {
+          const remaining = this.lineBuffer;
+          this.lineBuffer = '';
+          this._processLog(remaining + '\n');
+        }
+        resolve();
+      });
     });
-    await done.promise;
+    if (finalizeArg) await this.evaluateFinalResult();
   }
 
   public async handleTapLog(tapLog: string) {
@@ -544,40 +538,17 @@ export class TapParser {
   }
 
   public async evaluateFinalResult() {
+    if (this.finalized) return;
+    this.finalized = true;
     this.receivedTests = this.testStore.length;
     const duration = Date.now() - this.startTime;
-
-    // check wether all tests ran
-    if (this.expectedTests === this.receivedTests) {
-      if (this.logger) {
-        this.logger.tapOutput(`${this.receivedTests} out of ${this.expectedTests} Tests completed!`);
-      }
-    } else {
-      if (this.logger) {
-        this.logger.error(`Only ${this.receivedTests} out of ${this.expectedTests} completed!`);
-      }
-    }
     if (!this.expectedTests && this.receivedTests === 0) {
-      if (this.logger) {
-        this.logger.error('No tests were defined. Therefore the testfile failed!');
-        this.logger.testFileEnd(0, 1, duration); // Count as 1 failure
-      }
+      this.handleExecutionError('No tests were defined.');
     } else if (this.expectedTests !== this.receivedTests) {
-      if (this.logger) {
-        this.logger.error('The amount of received tests and expectedTests is unequal! Therefore the testfile failed');
-        const errorCount = this.getErrorTests().length || 1; // At least 1 error
-        this.logger.testFileEnd(this.receivedTests - errorCount, errorCount, duration);
-      }
-    } else if (this.getErrorTests().length === 0) {
-      if (this.logger) {
-        this.logger.tapOutput('All tests are successfull!!!');
-        this.logger.testFileEnd(this.receivedTests, 0, duration);
-      }
-    } else {
-      if (this.logger) {
-        this.logger.tapOutput(`${this.getErrorTests().length} tests threw an error!!!`, true);
-        this.logger.testFileEnd(this.receivedTests - this.getErrorTests().length, this.getErrorTests().length, duration);
-      }
+      this.handleExecutionError(`Only ${this.receivedTests} out of ${this.expectedTests} tests completed.`);
     }
+    for (const error of this.executionErrors) this.logger?.testErrorDetails(error);
+    const failedTests = this.getErrorTests().length;
+    this.logger?.testFileEnd(this.receivedTests - failedTests, failedTests, duration, this.executionErrors);
   }
-}
+}

package/ts/tstest.classes.testfile.directives.ts

@@ -165,7 +165,7 @@ function directivesToDenoOptions(directives: IParsedDirectives): DenoOptions | u
 
   if (useAllowAll) {
     // --allow-all replaces individual permissions, but keep compatibility flags
-    options.permissions = ['--allow-all', '--node-modules-dir', '--sloppy-imports'];
+    options.permissions = ['--allow-all', '--sloppy-imports'];
   } else if (extraPermissions.length > 0) {
     // Start with defaults and add extra permissions (deduplicated)
     const allPermissions = [...DENO_DEFAULT_PERMISSIONS];

package/ts/tstest.classes.tstest.ts

@@ -12,7 +12,7 @@ import type { LogOptions } from './tstest.logging.js';
 
 // Runtime adapters
 import { parseTestFilename, isDockerTestFile, parseDockerTestFilename } from './tstest.classes.runtime.parser.js';
-import { RuntimeAdapterRegistry } from './tstest.classes.runtime.adapter.js';
+import { RuntimeAdapterRegistry, type RuntimeAdapter, type RuntimeOptions } from './tstest.classes.runtime.adapter.js';
 import { NodeRuntimeAdapter } from './tstest.classes.runtime.node.js';
 import { ChromiumRuntimeAdapter } from './tstest.classes.runtime.chromium.js';
 import { DenoRuntimeAdapter } from './tstest.classes.runtime.deno.js';
@@ -318,14 +318,14 @@ export class TsTest {
           { TSTEST_FILE: fileNameArg, TSTEST_RUNTIME: adapter.id },
         );
         if (!success) {
-          this.logger.error(`test:before:testfile failed for ${fileName}. Skipping test file.`);
+          await this.recordRuntimeFailure(fileNameArg, adapter.displayName, fileIndex, totalFiles,
+            tapCombinator, 'test:before:testfile failed.');
           return;
         }
       }
 
       const options = hasDirectives(directives) ? directivesToRuntimeOptions(directives, adapter.id) : undefined;
-      const tapParser = await adapter.run(fileNameArg, fileIndex, totalFiles, options);
-      tapCombinator.addTapParser(tapParser);
+      await this.runAdapter(adapter, fileNameArg, fileIndex, totalFiles, tapCombinator, options);
     } else {
       // Multiple runtimes - use sections
       for (let i = 0; i < adapters.length; i++) {
@@ -342,20 +342,40 @@ export class TsTest {
             { TSTEST_FILE: fileNameArg, TSTEST_RUNTIME: adapter.id },
           );
           if (!success) {
-            this.logger.error(`test:before:testfile failed for ${fileName} on ${adapter.displayName}. Skipping.`);
+            await this.recordRuntimeFailure(fileNameArg, adapter.displayName, fileIndex, totalFiles,
+              tapCombinator, 'test:before:testfile failed.');
             this.logger.sectionEnd();
             continue;
           }
         }
 
         const options = hasDirectives(directives) ? directivesToRuntimeOptions(directives, adapter.id) : undefined;
-        const tapParser = await adapter.run(fileNameArg, fileIndex, totalFiles, options);
-        tapCombinator.addTapParser(tapParser);
+        await this.runAdapter(adapter, fileNameArg, fileIndex, totalFiles, tapCombinator, options);
         this.logger.sectionEnd();
       }
     }
   }
 
+  private async recordRuntimeFailure(fileArg: string, runtimeArg: string, indexArg: number,
+    totalArg: number, combinatorArg: TapCombinator, errorArg: unknown): Promise<void> {
+    const logger = this.logger.createTestFileLogger();
+    logger.testFileStart(fileArg, runtimeArg, indexArg, totalArg);
+    const parser = new TapParser(`${fileArg}:${runtimeArg}`, logger);
+    parser.handleExecutionError(errorArg instanceof Error ? errorArg.message : String(errorArg));
+    await parser.evaluateFinalResult();
+    combinatorArg.addTapParser(parser);
+  }
+
+  private async runAdapter(adapterArg: RuntimeAdapter, fileArg: string, indexArg: number,
+    totalArg: number, combinatorArg: TapCombinator, optionsArg?: RuntimeOptions): Promise<void> {
+    try {
+      combinatorArg.addTapParser(await adapterArg.run(fileArg, indexArg, totalArg, optionsArg));
+    } catch (errorArg) {
+      await this.recordRuntimeFailure(fileArg, adapterArg.displayName, indexArg, totalArg,
+        combinatorArg, errorArg);
+    }
+  }
+
   /**
    * Execute a Docker test file
    */
@@ -366,7 +386,8 @@ export class TsTest {
     tapCombinator: TapCombinator
   ): Promise<void> {
     if (!this.dockerAdapter) {
-      this.logger.tapOutput(cs('❌ Docker adapter not initialized', 'red'));
+      await this.recordRuntimeFailure(fileNameArg, 'Docker', fileIndex, totalFiles,
+        tapCombinator, 'Docker adapter not initialized.');
       return;
     }
 
@@ -380,7 +401,8 @@ export class TsTest {
         { TSTEST_FILE: fileNameArg, TSTEST_RUNTIME: 'docker' },
       );
       if (!success) {
-        this.logger.error(`test:before:testfile failed for ${fileNameArg}. Skipping.`);
+        await this.recordRuntimeFailure(fileNameArg, 'Docker', fileIndex, totalFiles,
+          tapCombinator, 'test:before:testfile failed.');
         return;
       }
     }
@@ -389,7 +411,8 @@ export class TsTest {
       const tapParser = await this.dockerAdapter.run(fileNameArg, fileIndex, totalFiles);
       tapCombinator.addTapParser(tapParser);
     } catch (error) {
-      this.logger.tapOutput(cs(`❌ Docker test failed: ${error.message}`, 'red'));
+      await this.recordRuntimeFailure(fileNameArg, 'Docker', fileIndex, totalFiles,
+        tapCombinator, error);
     }
   }
 

package/ts/tstest.logging.ts

@@ -17,6 +17,7 @@ export interface TestFileResult {
   failed: number;
   total: number;
   duration: number;
+  executionErrors?: string[];
   tests: Array<{
     name: string;
     passed: boolean;
@@ -30,6 +31,7 @@ export interface TestSummary {
   totalTests: number;
   totalPassed: number;
   totalFailed: number;
+  failedFiles: number;
   totalSkipped: number;
   totalDuration: number;
   fileResults: TestFileResult[];
@@ -50,6 +52,13 @@ export class TsTestLogger {
     this.options = options;
     this.startTime = Date.now();
   }
+
+  /** Keep each concurrent file's counters and log buffers separate. */
+  public createTestFileLogger(): TsTestLogger {
+    const logger = new TsTestLogger(this.options);
+    logger.fileResults = this.fileResults;
+    return logger;
+  }
   
   private format(text: string, color?: string): string {
     if (this.options.noColor || !color) {
@@ -305,14 +314,20 @@ export class TsTestLogger {
     this.currentTestLogs = [];
   }
   
-  testFileEnd(passed: number, failed: number, duration: number) {
+  testFileEnd(passed: number, failed: number, duration: number, executionErrors: readonly string[] = []) {
+    const fileFailed = failed > 0 || executionErrors.length > 0;
     if (this.currentFileResult) {
+      this.currentFileResult.passed = passed;
+      this.currentFileResult.failed = failed;
+      this.currentFileResult.total = passed + failed;
+      this.currentFileResult.duration = duration;
+      this.currentFileResult.executionErrors = [...executionErrors];
       this.fileResults.push(this.currentFileResult);
       this.currentFileResult = null;
     }
     
     if (this.options.json) {
-      this.logJson({ event: 'fileEnd', passed, failed, duration });
+      this.logJson({ event: 'fileEnd', passed, failed, duration, executionErrors, fileFailed });
       return;
     }
     
@@ -320,10 +335,10 @@ export class TsTestLogger {
       const total = passed + failed;
       const durationStr = duration >= 1000 ? `${(duration / 1000).toFixed(1)}s` : `${duration}ms`;
       
-      if (failed === 0) {
+      if (!fileFailed) {
         this.log(this.format(`   Summary: ${passed}/${total} PASSED in ${durationStr}`, 'green'));
       } else {
-        this.log(this.format(`   Summary: ${passed} passed, ${failed} failed of ${total} tests in ${durationStr}`, 'red'));
+        this.log(this.format(`   Summary: FAILED — ${passed} passed, ${failed} failed of ${total} tests; ${executionErrors.length} execution errors in ${durationStr}`, 'red'));
       }
     }
     
@@ -335,7 +350,7 @@ export class TsTestLogger {
         const logBasename = path.basename(this.currentTestLogFile);
         
         // Create error copy if there were failures
-        if (failed > 0) {
+        if (fileFailed) {
           const errorDir = path.join(logDir, '00err');
           if (!fs.existsSync(errorDir)) {
             fs.mkdirSync(errorDir, { recursive: true });
@@ -509,6 +524,7 @@ export class TsTestLogger {
       totalTests: this.fileResults.reduce((sum, r) => sum + r.total, 0),
       totalPassed: this.fileResults.reduce((sum, r) => sum + r.passed, 0),
       totalFailed: this.fileResults.reduce((sum, r) => sum + r.failed, 0),
+      failedFiles: this.fileResults.filter((r) => r.failed > 0 || r.executionErrors?.length > 0).length,
       totalSkipped: skippedFiles.length,
       totalDuration,
       fileResults: this.fileResults,
@@ -521,13 +537,13 @@ export class TsTestLogger {
     }
     
     if (this.options.quiet) {
-      const status = summary.totalFailed === 0 ? 'PASSED' : 'FAILED';
+      const status = summary.failedFiles === 0 ? 'PASSED' : 'FAILED';
       const durationStr = totalDuration >= 1000 ? `${(totalDuration / 1000).toFixed(1)}s` : `${totalDuration}ms`;
       
-      if (summary.totalFailed === 0) {
+      if (summary.failedFiles === 0) {
         this.log(`\nSummary: ${summary.totalPassed}/${summary.totalTests} | ${durationStr} | ${status}`);
       } else {
-        this.log(`\nSummary: ${summary.totalPassed} passed, ${summary.totalFailed} failed of ${summary.totalTests} tests | ${durationStr} | ${status}`);
+        this.log(`\nSummary: ${summary.totalPassed} passed, ${summary.totalFailed} failed of ${summary.totalTests} tests | ${summary.failedFiles} failed files | ${durationStr} | ${status}`);
       }
       return;
     }
@@ -539,6 +555,7 @@ export class TsTestLogger {
     this.log(this.format(`│ Total Tests:    ${summary.totalTests.toString().padStart(14)} │`, 'white'));
     this.log(this.format(`│ Passed:         ${summary.totalPassed.toString().padStart(14)} │`, 'green'));
     this.log(this.format(`│ Failed:         ${summary.totalFailed.toString().padStart(14)} │`, summary.totalFailed > 0 ? 'red' : 'green'));
+    this.log(this.format(`│ Failed Files:   ${summary.failedFiles.toString().padStart(14)} │`, summary.failedFiles > 0 ? 'red' : 'green'));
     if (summary.totalSkipped > 0) {
       this.log(this.format(`│ Skipped:        ${summary.totalSkipped.toString().padStart(14)} │`, 'yellow'));
     }
@@ -547,11 +564,14 @@ export class TsTestLogger {
     this.log(this.format('└────────────────────────────────┘', 'dim'));
     
     // File results
-    if (summary.totalFailed > 0) {
+    if (summary.failedFiles > 0) {
       this.log(this.format('\n❌ Failed Tests:', 'red'));
       this.fileResults.forEach(fileResult => {
-        if (fileResult.failed > 0) {
+        if (fileResult.failed > 0 || fileResult.executionErrors?.length > 0) {
           this.log(this.format(`\n   ${fileResult.file}`, 'yellow'));
+          for (const error of fileResult.executionErrors || []) {
+            this.log(this.format(`      ❌ ${error}`, 'red'));
+          }
           fileResult.tests.filter(t => !t.passed).forEach(test => {
             this.log(this.format(`      ❌ ${test.name}`, 'red'));
             if (test.error) {
@@ -585,8 +605,8 @@ export class TsTestLogger {
     }
     
     // Final status
-    const status = summary.totalFailed === 0 ? 'ALL TESTS PASSED! 🎉' : 'SOME TESTS FAILED! ❌';
-    const statusColor = summary.totalFailed === 0 ? 'green' : 'red';
+    const status = summary.failedFiles === 0 ? 'ALL TESTS PASSED! 🎉' : 'SOME TESTS FAILED! ❌';
+    const statusColor = summary.failedFiles === 0 ? 'green' : 'red';
     this.log(this.format(`\n${status}`, statusColor));
   }
   
@@ -710,4 +730,4 @@ export class TsTestLogger {
     
     this.log(this.format('\n\n👋 Stopping watch mode...', 'cyan'));
   }
-}
+}

package/ts/tstest.plugins.ts

@@ -1,8 +1,9 @@
 // node native
 import * as fs from 'fs';
 import * as path from 'path';
+import * as url from 'node:url';
 
-export { fs, path };
+export { fs, path, url };
 
 // @push.rocks scope
 import * as consolecolor from '@push.rocks/consolecolor';