@git.zone/tstest 4.1.1 → 6.0.0

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

@@ -20,7 +20,6 @@ export const DENO_DEFAULT_PERMISSIONS = [
   '--allow-write',
   '--allow-sys',
   '--allow-import',
-  '--node-modules-dir',
   '--sloppy-imports',
 ];
 
@@ -45,20 +44,9 @@ export class DenoRuntimeAdapter extends RuntimeAdapter {
    * Get default Deno options
    */
   protected getDefaultOptions(): DenoOptions {
-    // Auto-detect deno.json or deno.jsonc config file for TypeScript decorator support
-    let configPath: string | undefined;
-    const denoJsonPath = plugins.path.join(process.cwd(), 'deno.json');
-    const denoJsoncPath = plugins.path.join(process.cwd(), 'deno.jsonc');
-
-    if (plugins.fs.existsSync(denoJsonPath)) {
-      configPath = denoJsonPath;
-    } else if (plugins.fs.existsSync(denoJsoncPath)) {
-      configPath = denoJsoncPath;
-    }
-
+    // Deno discovers the project's config and node_modules mode itself.
     return {
       ...super.getDefaultOptions(),
-      configPath,
       permissions: [...DENO_DEFAULT_PERMISSIONS],
     };
   }
@@ -152,130 +140,58 @@ export class DenoRuntimeAdapter extends RuntimeAdapter {
     total: number,
     options?: DenoOptions
   ): Promise<TapParser> {
-    this.logger.testFileStart(testFile, this.displayName, index, total);
-    const tapParser = new TapParser(testFile + ':deno', this.logger);
-
-    const mergedOptions = this.mergeOptions(options) as DenoOptions;
-
-    // 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.smartfsInstance.file(initFile).exists();
-
-    let runCommand = fullCommand;
-    let loaderPath: string | null = 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.smartfsInstance.file(loaderPath).write(loaderContent);
-
-      // Rebuild command with loader file
-      const loaderCommand = this.createCommand(loaderPath, mergedOptions);
-      runCommand = `${loaderCommand.command} ${loaderCommand.args.join(' ')}`;
-    }
-
-    // Pre-resolve dependencies for the Deno test entrypoint
-    const installTarget = loaderPath || testFile;
-    const installArgs = ['install', '--entrypoint', installTarget];
-    if (mergedOptions.configPath) {
-      installArgs.push('--config', mergedOptions.configPath);
-    }
-    const installCommand = `deno ${installArgs.join(' ')}`;
-    console.log(cs(`   ⏳ Resolving Deno dependencies for ${plugins.path.basename(testFile)}...`, 'blue'));
-    await this.smartshellInstance.execSilent(installCommand, { cwd: process.cwd() });
-    console.log(cs(`   ✓ Deno dependencies resolved`, 'green'));
-
-    const execResultStreaming = await this.smartshellInstance.execStreamingSilent(runCommand);
+    const logger = this.logger.createTestFileLogger();
+    logger.testFileStart(testFile, this.displayName, index, total);
+    const tapParser = new TapParser(testFile + ':deno', logger);
 
-    // If we created a loader file, clean it up after test execution
-    if (loaderPath) {
-      const cleanup = () => {
-        try {
-          if (plugins.fs.existsSync(loaderPath)) {
-            plugins.fs.rmSync(loaderPath, { force: true });
-          }
-        } 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: NodeJS.Timeout | null = 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: NodeJS.Timeout;
-
-      const timeoutPromise = new Promise<void>((_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);
+    let loaderPath: string | undefined;
+    let timer: NodeJS.Timeout | undefined;
+    try {
+      const mergedOptions = this.mergeOptions(options) as DenoOptions;
+      const absoluteTestFile = plugins.path.resolve(mergedOptions.cwd || process.cwd(), testFile);
+      const testDir = plugins.path.dirname(absoluteTestFile);
+      const initFile = plugins.path.join(testDir, '00init.ts');
+      if (await plugins.smartfsInstance.file(initFile).exists()) {
+        loaderPath = plugins.path.join(testDir,
+          `.${plugins.path.basename(testFile)}.${process.pid}.${Date.now()}.loader.ts`);
+        const loaderContent = [initFile, absoluteTestFile].map((fileArg) =>
+          `import ${JSON.stringify(plugins.url.pathToFileURL(fileArg).href)};`).join('\n');
+        await plugins.smartfsInstance.file(loaderPath).write(loaderContent);
+      }
+      const command = this.createCommand(loaderPath || absoluteTestFile, mergedOptions);
+      const quote = (valueArg: string) => "'" + valueArg.replaceAll("'", "'\\''") + "'";
+      const runCommand = [command.command, ...command.args].map(quote).join(' ');
+      // One Deno invocation honors project defaults and explicit manual/auto flags.
+      const execution = await this.smartshellInstance.execStreamingSilent(runCommand, {
+        cwd: command.cwd,
+        env: { ...process.env, ...command.env },
       });
-
-      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
+      if (this.timeoutSeconds !== null) {
+        timer = setTimeout(() => {
+          tapParser.handleTimeout(this.timeoutSeconds);
+          void execution.kill().catch((errorArg: Error) => {
+            tapParser.handleExecutionError(`Unable to terminate timed out test: ${errorArg.message}`);
+          });
+        }, this.timeoutSeconds * 1000);
+      } else {
+        timer = setTimeout(() => {
+          logger.warning(`Test file ${testFile} has run for more than one minute; use --timeout to limit execution.`);
+        }, 60000);
+      }
+      await tapParser.handleTapProcess(execution.childProcess, false);
+    } catch (errorArg) {
+      tapParser.handleExecutionError(errorArg instanceof Error ? errorArg.message : String(errorArg));
+    } finally {
+      if (timer) clearTimeout(timer);
+      if (loaderPath) {
         try {
-          await execResultStreaming.kill(); // This kills the entire process tree with SIGKILL
-        } catch (killError) {
-          // Process tree might already be dead
+          await plugins.fs.promises.rm(loaderPath, { force: true });
+        } catch (errorArg) {
+          tapParser.handleExecutionError(`Failed to remove Deno loader: ${String(errorArg)}`);
         }
-        await tapParser.evaluateFinalResult();
       }
-    } else {
-      await tapParser.handleTapProcess(execResultStreaming.childProcess);
-    }
-
-    // Clear warning timer if it was set
-    if (warningTimer) {
-      clearTimeout(warningTimer);
+      await tapParser.evaluateFinalResult();
     }
-
     return tapParser;
   }
 }

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);
     }
   }