@travetto/test 7.1.4 → 8.0.0-alpha.1

package/src/consumer/types/tap.ts

@@ -1,8 +1,8 @@
 import path from 'node:path';
 import { stringify } from 'yaml';
 
-import { Terminal } from '@travetto/terminal';
-import { TimeUtil, RuntimeIndex, hasToJSON } from '@travetto/runtime';
+import { Terminal, StyleUtil } from '@travetto/terminal';
+import { TimeUtil, RuntimeIndex, hasToJSON, JSONUtil } from '@travetto/runtime';
 
 import type { TestEvent } from '../../model/event.ts';
 import type { SuitesSummary, TestConsumerShape } from '../types.ts';
@@ -41,15 +41,15 @@ export class TapEmitter implements TestConsumerShape {
    */
   onStart(): void {
     this.#start = Date.now();
-    this.log(this.#enhancer.suiteName('TAP version 14')!);
+    this.log(this.#enhancer.suiteName('TAP version 14'));
   }
 
   /**
    * Output supplemental data (e.g. logs)
    */
-  logMeta(meta: Record<string, unknown>): void {
+  logMeta(metadata: Record<string, unknown>): void {
     const lineLength = this.#terminal.width - 5;
-    let body = stringify(meta, { lineWidth: lineLength, indent: 2 });
+    let body = stringify(metadata, { lineWidth: lineLength, indent: 2 });
     body = body.split('\n').map(line => `  ${line}`).join('\n');
     this.log(`---\n${this.#enhancer.objectInspect(body)}\n...`);
   }
@@ -61,7 +61,7 @@ export class TapEmitter implements TestConsumerShape {
   errorToString(error?: Error): string | undefined {
     if (error && error.name !== 'AssertionError') {
       if (error instanceof Error) {
-        let out = JSON.stringify(hasToJSON(error) ? error.toJSON() : error, null, 2);
+        let out = JSONUtil.toUTF8(hasToJSON(error) ? error.toJSON() : error, { indent: 2 });
         if (this.#options?.verbose && error.stack) {
           out = `${out}\n${error.stack}`;
         }
@@ -79,23 +79,33 @@ export class TapEmitter implements TestConsumerShape {
     if (event.type === 'test' && event.phase === 'after') {
       const { test } = event;
       const suiteId = this.#enhancer.suiteName(test.classId);
-      let header = `${suiteId} - ${this.#enhancer.testName(test.methodName)}`;
-      if (test.description) {
-        header += `: ${this.#enhancer.testDescription(test.description)}`;
-      }
+      const suiteSourceFile = RuntimeIndex.getFromImport(test.import)!.sourceFile;
+      const testSourceFile = test.declarationImport ? RuntimeIndex.getFromImport(test.declarationImport)!.sourceFile : suiteSourceFile;
+
+      const header = [
+        StyleUtil.link(suiteId, `file://${suiteSourceFile}#${test.suiteLineStart ?? 1}`),
+        ' - ',
+        StyleUtil.link(this.#enhancer.testName(test.methodName), `file://${testSourceFile}#${test.lineStart}`),
+        ...test.description ? [`: ${this.#enhancer.testDescription(test.description)}`] : []
+      ].join('');
+
       this.log(`# ${header}`);
 
       // Handle each assertion
       if (test.assertions.length) {
         let subCount = 0;
         for (const asrt of test.assertions) {
+          const assertSourceFile = RuntimeIndex.getFromImport(asrt.import)!.sourceFile;
           const text = asrt.message ? `${asrt.text} (${this.#enhancer.failure(asrt.message)})` : asrt.text;
-          const pth = asrt.import ? `./${path.relative(process.cwd(), RuntimeIndex.getFromImport(asrt.import)!.sourceFile)}` : '<unknown>';
+          const location = asrt.import ? `./${path.relative(process.cwd(), assertSourceFile)}` : '<unknown>';
           let subMessage = [
             this.#enhancer.assertNumber(++subCount),
             '-',
             this.#enhancer.assertDescription(text),
-            `${this.#enhancer.assertFile(pth)}:${this.#enhancer.assertLine(asrt.line)}`
+            StyleUtil.link(
+              `${this.#enhancer.assertFile(location)}:${this.#enhancer.assertLine(asrt.line)}`,
+              `file://${assertSourceFile}#${asrt.line}`
+            )
           ].join(' ');
 
           if (asrt.error) {
@@ -124,10 +134,16 @@ export class TapEmitter implements TestConsumerShape {
       this.log(status);
 
       // Handle error
-      if (test.status === 'failed' && test.error) {
-        const msg = this.errorToString(test.error);
-        if (msg) {
-          this.logMeta({ error: msg });
+      switch (test.status) {
+        case 'errored':
+        case 'failed': {
+          if (test.error) {
+            const msg = this.errorToString(test.error);
+            if (msg) {
+              this.logMeta({ error: msg });
+            }
+          }
+          break;
         }
       }
 
@@ -162,13 +178,15 @@ export class TapEmitter implements TestConsumerShape {
       }
     }
 
-    const allPassed = summary.failed === 0;
+    const allPassed = !summary.failed && !summary.errored;
 
     this.log([
       this.#enhancer[allPassed ? 'success' : 'failure']('Results'),
       `${this.#enhancer.total(summary.passed)}/${this.#enhancer.total(summary.total)},`,
       allPassed ? 'failed' : this.#enhancer.failure('failed'),
       `${this.#enhancer.total(summary.failed)}`,
+      allPassed ? 'errored' : this.#enhancer.failure('errored'),
+      `${this.#enhancer.total(summary.errored)}`,
       'skipped',
       this.#enhancer.total(summary.skipped),
       `# (Total Test Time: ${TimeUtil.asClock(summary.duration)}, Total Run Time: ${TimeUtil.asClock(Date.now() - this.#start)})`

package/src/consumer/types/xunit.ts

@@ -24,18 +24,18 @@ export class XunitEmitter implements TestConsumerShape {
   /**
    * Process metadata information (e.g. logs)
    */
-  buildMeta(meta: Record<string, unknown>): string {
-    if (!meta) {
+  buildMeta(metadata: Record<string, unknown>): string {
+    if (!metadata) {
       return '';
     }
 
-    for (const key of Object.keys(meta)) {
-      if (!meta[key]) {
-        delete meta[key];
+    for (const key of Object.keys(metadata)) {
+      if (!metadata[key]) {
+        delete metadata[key];
       }
     }
-    if (Object.keys(meta).length) {
-      let body = stringify(meta);
+    if (Object.keys(metadata).length) {
+      let body = stringify(metadata);
       body = body.split('\n').map(line => `  ${line}`).join('\n');
       return `<![CDATA[\n${body}\n]]>`;
     } else {
@@ -60,7 +60,8 @@ export class XunitEmitter implements TestConsumerShape {
 
       if (test.error) {
         const assertion = test.assertions.find(item => !!item.error)!;
-        body = `<failure type="${assertion.text}" message="${encodeURIComponent(assertion.message!)}"><![CDATA[${assertion.error!.stack}]]></failure>`;
+        const node = test.status === 'failed' ? 'failure' : 'error';
+        body = `<${node} type="${assertion.text}" message="${encodeURIComponent(assertion.message!)}"><![CDATA[${assertion.error!.stack}]]></${node}>`;
       }
 
       const groupedByLevel: Record<string, string[]> = {};
@@ -90,7 +91,7 @@ export class XunitEmitter implements TestConsumerShape {
     time="${suite.duration}"
     tests="${suite.total}"
     failures="${suite.failed}"
-    errors="${suite.failed}"
+    errors="${suite.errored}"
     skipped="${suite.skipped}"
     file="${RuntimeIndex.getFromImport(suite.import)!.sourceFile}"
   >
@@ -112,7 +113,8 @@ export class XunitEmitter implements TestConsumerShape {
   time="${summary.duration}"
   tests="${summary.total}"
   failures="${summary.failed}"
-  errors="${summary.failed}"
+  errors="${summary.errored}"
+  skipped="${summary.skipped}"
 >
  ${this.#suites.join('\n')}
 </testsuites>

package/src/decorator/suite.ts

@@ -1,10 +1,8 @@
-import { castTo, type Class, type ClassInstance, describeFunction, getClass } from '@travetto/runtime';
+import { castTo, type Class, type ClassInstance, getClass } from '@travetto/runtime';
 
 import type { SuiteConfig } from '../model/suite.ts';
 import { SuiteRegistryIndex } from '../registry/registry-index.ts';
 
-export type SuitePhase = 'beforeAll' | 'beforeEach' | 'afterAll' | 'afterEach';
-
 /**
  * Register a class to be defined as a test suite, and a candidate for testing
  * @param description The Suite description
@@ -17,11 +15,9 @@ export function Suite(...rest: Partial<SuiteConfig>[]): ClassDecorator;
 export function Suite(description: string, ...rest: Partial<SuiteConfig>[]): ClassDecorator;
 export function Suite(description?: string | Partial<SuiteConfig>, ...rest: Partial<SuiteConfig>[]): ClassDecorator {
   const decorator = (cls: Class): typeof cls => {
-    const isAbstract = describeFunction(cls).abstract;
     SuiteRegistryIndex.getForRegister(cls).register(
       ...(typeof description !== 'string' && description ? [description] : []),
       ...rest,
-      ...isAbstract ? [{ skip: true }] : [],
       ...(typeof description === 'string' ? [{ description }] : []),
     );
     return cls;
@@ -36,7 +32,9 @@ export function Suite(description?: string | Partial<SuiteConfig>, ...rest: Part
  */
 export function BeforeAll() {
   return (instance: ClassInstance, property: string, descriptor: PropertyDescriptor): PropertyDescriptor => {
-    SuiteRegistryIndex.getForRegister(getClass(instance)).register({ beforeAll: [descriptor.value] });
+    SuiteRegistryIndex.getForRegister(getClass(instance)).register({
+      phaseHandlers: [{ beforeAll: (realInstance: unknown): unknown => descriptor.value.call(realInstance) }]
+    });
     return descriptor;
   };
 }
@@ -47,7 +45,9 @@ export function BeforeAll() {
  */
 export function BeforeEach() {
   return (instance: ClassInstance, property: string, descriptor: PropertyDescriptor): PropertyDescriptor => {
-    SuiteRegistryIndex.getForRegister(getClass(instance)).register({ beforeEach: [descriptor.value] });
+    SuiteRegistryIndex.getForRegister(getClass(instance)).register({
+      phaseHandlers: [{ beforeEach: (realInstance: unknown): unknown => descriptor.value.call(realInstance) }]
+    });
     return descriptor;
   };
 }
@@ -58,7 +58,9 @@ export function BeforeEach() {
  */
 export function AfterAll() {
   return (instance: ClassInstance, property: string, descriptor: PropertyDescriptor): PropertyDescriptor => {
-    SuiteRegistryIndex.getForRegister(getClass(instance)).register({ afterAll: [descriptor.value] });
+    SuiteRegistryIndex.getForRegister(getClass(instance)).register({
+      phaseHandlers: [{ afterAll: (realInstance: unknown): unknown => descriptor.value.call(realInstance) }]
+    });
     return descriptor;
   };
 }
@@ -69,7 +71,9 @@ export function AfterAll() {
  */
 export function AfterEach() {
   return (instance: ClassInstance, property: string, descriptor: PropertyDescriptor): PropertyDescriptor => {
-    SuiteRegistryIndex.getForRegister(getClass(instance)).register({ afterEach: [descriptor.value] });
+    SuiteRegistryIndex.getForRegister(getClass(instance)).register({
+      phaseHandlers: [{ afterEach: (realInstance: unknown): unknown => descriptor.value.call(realInstance) }]
+    });
     return descriptor;
   };
 }

package/src/execute/barrier.ts

@@ -3,7 +3,7 @@ import { createHook, executionAsyncId } from 'node:async_hooks';
 
 import { type TimeSpan, TimeUtil, Util } from '@travetto/runtime';
 
-import { ExecutionError, TimeoutError } from './error.ts';
+import { TestExecutionError, TimeoutError } from '../model/error.ts';
 
 const UNCAUGHT_ERR_EVENTS = ['unhandledRejection', 'uncaughtException'] as const;
 
@@ -13,7 +13,7 @@ export class Barrier {
    */
   static timeout(duration: number | TimeSpan, operation: string = 'Operation'): { promise: Promise<void>, resolve: () => unknown } {
     const resolver = Promise.withResolvers<void>();
-    const durationMs = TimeUtil.asMillis(duration);
+    const durationMs = TimeUtil.duration(duration, 'ms');
     let timeout: NodeJS.Timeout;
     if (!durationMs) {
       resolver.resolve();
@@ -67,7 +67,7 @@ export class Barrier {
           await Util.queueMacroTask();
           i -= 1;
           if (i === 0) {
-            throw new ExecutionError(`Pending promises: ${pending.size}`);
+            throw new TestExecutionError(`Pending promises: ${pending.size}`);
           }
         }
       },

package/src/execute/executor.ts

@@ -1,10 +1,8 @@
-import { AssertionError } from 'node:assert';
-
 import { Env, TimeUtil, Runtime, castTo, classConstruct } from '@travetto/runtime';
 import { Registry } from '@travetto/registry';
 
 import type { TestConfig, TestResult, TestRun } from '../model/test.ts';
-import type { SuiteConfig, SuiteFailure, SuiteResult } from '../model/suite.ts';
+import type { SuiteConfig, SuiteResult } from '../model/suite.ts';
 import type { TestConsumerShape } from '../consumer/types.ts';
 import { AssertCheck } from '../assert/check.ts';
 import { AssertCapture } from '../assert/capture.ts';
@@ -12,11 +10,10 @@ import { ConsoleCapture } from './console.ts';
 import { TestPhaseManager } from './phase.ts';
 import { AssertUtil } from '../assert/util.ts';
 import { Barrier } from './barrier.ts';
-import { ExecutionError } from './error.ts';
 import { SuiteRegistryIndex } from '../registry/registry-index.ts';
 import { TestModelUtil } from '../model/util.ts';
 
-const TEST_TIMEOUT = TimeUtil.fromValue(Env.TRV_TEST_TIMEOUT.value) ?? 5000;
+const TEST_TIMEOUT = TimeUtil.duration(Env.TRV_TEST_TIMEOUT.value || 5000, 'ms');
 
 /**
  * Support execution of the tests
@@ -29,25 +26,21 @@ export class TestExecutor {
     this.#consumer = consumer;
   }
 
-  /**
-   * Handles communicating a suite-level error
-   * @param failure
-   * @param withSuite
-   */
-  #onSuiteFailure(failure: SuiteFailure, triggerSuite?: boolean): void {
-    if (triggerSuite) {
-      this.#consumer.onEvent({ type: 'suite', phase: 'before', suite: failure.suite });
+  #onSuiteTestError(result: TestResult, test: TestConfig): void {
+    this.#consumer.onEvent({ type: 'test', phase: 'before', test });
+    for (const assertion of result.assertions) {
+      this.#consumer.onEvent({ type: 'assertion', phase: 'after', assertion });
     }
+    this.#consumer.onEvent({ type: 'test', phase: 'after', test: result });
+  }
 
-    this.#consumer.onEvent({ type: 'test', phase: 'before', test: failure.test });
-    this.#consumer.onEvent({ type: 'assertion', phase: 'after', assertion: failure.assert });
-    this.#consumer.onEvent({ type: 'test', phase: 'after', test: failure.testResult });
-
-    if (triggerSuite) {
-      this.#consumer.onEvent({
-        type: 'suite', phase: 'after',
-        suite: { ...castTo(failure.suite), failed: 1, passed: 0, total: 1, skipped: 0 }
-      });
+  #recordSuiteErrors(suiteConfig: SuiteConfig, suiteResult: SuiteResult, errors: TestResult[]): void {
+    for (const test of errors) {
+      if (!suiteResult.tests[test.methodName]) {
+        this.#onSuiteTestError(test, suiteConfig.tests[test.methodName]);
+        suiteResult.errored += 1;
+        suiteResult.total += 1;
+      }
     }
   }
 
@@ -83,17 +76,27 @@ export class TestExecutor {
   #skipTest(test: TestConfig, result: SuiteResult): void {
     // Mark test start
     this.#consumer.onEvent({ type: 'test', phase: 'before', test });
-    result.skipped++;
-    this.#consumer.onEvent({ type: 'test', phase: 'after', test: { ...test, assertions: [], duration: 0, durationTotal: 0, output: [], status: 'skipped' } });
+    result.skipped += 1;
+    result.total += 1;
+    this.#consumer.onEvent({
+      type: 'test',
+      phase: 'after',
+      test: {
+        ...test,
+        suiteLineStart: result.lineStart,
+        assertions: [], duration: 0, durationTotal: 0, output: [], status: 'skipped'
+      }
+    });
   }
 
   /**
    * An empty suite result based on a suite config
    */
-  createSuiteResult(suite: SuiteConfig): SuiteResult {
+  createSuiteResult(suite: SuiteConfig, override?: Partial<SuiteResult>): SuiteResult {
     return {
       passed: 0,
       failed: 0,
+      errored: 0,
       skipped: 0,
       unknown: 0,
       total: 0,
@@ -104,14 +107,15 @@ export class TestExecutor {
       classId: suite.classId,
       sourceHash: suite.sourceHash,
       duration: 0,
-      tests: {}
+      tests: {},
+      ...override
     };
   }
 
   /**
    * Execute the test, capture output, assertions and promises
    */
-  async executeTest(test: TestConfig): Promise<TestResult> {
+  async executeTest(test: TestConfig, suite: SuiteConfig): Promise<TestResult> {
 
     // Mark test start
     this.#consumer.onEvent({ type: 'test', phase: 'before', test });
@@ -123,11 +127,12 @@ export class TestExecutor {
       description: test.description,
       classId: test.classId,
       tags: test.tags,
+      suiteLineStart: suite.lineStart,
       lineStart: test.lineStart,
       lineEnd: test.lineEnd,
       lineBodyStart: test.lineBodyStart,
       import: test.import,
-      sourceImport: test.sourceImport,
+      declarationImport: test.declarationImport,
       sourceHash: test.sourceHash,
       status: 'unknown',
       assertions: [],
@@ -148,28 +153,15 @@ export class TestExecutor {
     const consoleCapture = new ConsoleCapture().start(); // Capture all output from transpiled code
 
     // Run method and get result
-    let error = await this.#executeTestMethod(test);
-
-    if (!error) {
-      error = AssertCheck.checkError(test.shouldThrow, error); // Rewrite error
-    } else {
-      if (error instanceof AssertionError) {
-        // Pass, do nothing
-      } else if (error instanceof ExecutionError) { // Errors that are not expected
-        AssertCheck.checkUnhandled(test, error);
-      } else if (test.shouldThrow) {
-        error = AssertCheck.checkError(test.shouldThrow, error); // Rewrite error
-      } else if (error instanceof Error) {
-        AssertCheck.checkUnhandled(test, error);
-      }
-    }
+    const error = await this.#executeTestMethod(test);
+    const [status, finalError] = AssertCheck.validateTestResultError(test, error);
 
     Object.assign(result, {
-      status: error ? 'failed' : 'passed',
+      status,
       output: consoleCapture.end(),
       assertions: getAssertions(),
       duration: Date.now() - startTime,
-      ...(error ? { error } : {})
+      ...(finalError ? { error: finalError } : {})
     });
 
     // Mark completion
@@ -185,7 +177,20 @@ export class TestExecutor {
 
     suite.instance = classConstruct(suite.class);
 
-    if (!tests.length || await this.#shouldSkip(suite, suite.instance)) {
+    const shouldSkip = await this.#shouldSkip(suite, suite.instance);
+
+    if (shouldSkip) {
+      this.#consumer.onEvent({
+        phase: 'after', type: 'suite',
+        suite: this.createSuiteResult(suite, {
+          status: 'skipped',
+          skipped: tests.length,
+          total: tests.length
+        })
+      });
+    }
+
+    if (shouldSkip || !tests.length) {
       return;
     }
 
@@ -200,7 +205,7 @@ export class TestExecutor {
     // Mark suite start
     this.#consumer.onEvent({ phase: 'before', type: 'suite', suite: { ...suite, tests: testConfigs } });
 
-    const manager = new TestPhaseManager(suite, result, event => this.#onSuiteFailure(event));
+    const manager = new TestPhaseManager(suite);
 
     const originalEnv = { ...process.env };
 
@@ -220,31 +225,37 @@ export class TestExecutor {
         process.env = { ...suiteEnv };
 
         const testStart = Date.now();
-
-        // Handle BeforeEach
-        await manager.startPhase('each');
-
-        // Run test
-        const testResult = await this.executeTest(test);
-        result[testResult.status]++;
-        result.tests[testResult.methodName] = testResult;
-
-        // Handle after each
-        await manager.endPhase('each');
-        testResult.durationTotal = Date.now() - testStart;
+        try {
+
+          // Handle BeforeEach
+          await manager.startPhase('each');
+
+          // Run test
+          const testResult = await this.executeTest(test, suite);
+          result.tests[testResult.methodName] = testResult;
+          result[testResult.status]++;
+          result.total += 1;
+
+          // Handle after each
+          await manager.endPhase('each');
+          testResult.durationTotal = Date.now() - testStart;
+        } catch (testError) {
+          const errors = await manager.errorPhase('each', testError, suite, test);
+          this.#recordSuiteErrors(suite, result, errors);
+        }
       }
 
       // Handle after all
       await manager.endPhase('all');
-    } catch (error) {
-      await manager.onError(error);
+    } catch (suiteError) {
+      const errors = await manager.errorPhase('all', suiteError, suite);
+      this.#recordSuiteErrors(suite, result, errors);
     }
 
     // Restore env
     process.env = { ...originalEnv };
 
     result.duration = Date.now() - startTime;
-    result.total = result.passed + result.failed + result.skipped;
     result.status = TestModelUtil.countsToTestStatus(result);
 
     // Mark suite complete
@@ -262,12 +273,17 @@ export class TestExecutor {
         throw error;
       }
       console.error(error);
-      this.#onSuiteFailure(AssertUtil.gernerateImportFailure(run.import, error));
+
+      // Fire import failure as a test failure for each test in the suite
+      const { result, test, suite } = AssertUtil.gernerateImportFailure(run.import, error);
+      this.#consumer.onEvent({ type: 'suite', phase: 'before', suite });
+      this.#onSuiteTestError(result, test);
+      this.#consumer.onEvent({ type: 'suite', phase: 'after', suite });
       return;
     }
 
     // Initialize registry (after loading the above)
-    await Registry.finalizeForIndex(SuiteRegistryIndex);
+    Registry.finalizeForIndex(SuiteRegistryIndex);
 
     // Convert inbound arguments to specific tests to run
     const suites = SuiteRegistryIndex.getSuiteTests(run);

package/src/execute/phase.ts

@@ -1,14 +1,11 @@
-import { Env, TimeUtil } from '@travetto/runtime';
+import { describeFunction, Env, TimeUtil } from '@travetto/runtime';
 
-import type { SuiteConfig, SuiteFailure, SuiteResult } from '../model/suite.ts';
+import type { SuiteConfig, SuitePhase } from '../model/suite.ts';
 import { AssertUtil } from '../assert/util.ts';
 import { Barrier } from './barrier.ts';
+import type { TestConfig, TestResult } from '../model/test.ts';
 
-class TestBreakout extends Error {
-  source?: Error;
-}
-
-const TEST_PHASE_TIMEOUT = TimeUtil.fromValue(Env.TRV_TEST_PHASE_TIMEOUT.value) ?? 15000;
+const TEST_PHASE_TIMEOUT = TimeUtil.duration(Env.TRV_TEST_PHASE_TIMEOUT.value ?? 15000, 'ms');
 
 /**
  * Test Phase Execution Manager.
@@ -18,34 +15,30 @@ const TEST_PHASE_TIMEOUT = TimeUtil.fromValue(Env.TRV_TEST_PHASE_TIMEOUT.value)
 export class TestPhaseManager {
   #progress: ('all' | 'each')[] = [];
   #suite: SuiteConfig;
-  #result: SuiteResult;
-  #onSuiteFailure: (fail: SuiteFailure) => void;
 
-  constructor(suite: SuiteConfig, result: SuiteResult, onSuiteFailure: (fail: SuiteFailure) => void) {
+  constructor(suite: SuiteConfig) {
     this.#suite = suite;
-    this.#result = result;
-    this.#onSuiteFailure = onSuiteFailure;
   }
 
   /**
    * Run a distinct phase of the test execution
    */
-  async runPhase(phase: 'beforeAll' | 'afterAll' | 'beforeEach' | 'afterEach'): Promise<void> {
+  async runPhase(phase: SuitePhase): Promise<void> {
     let error: Error | undefined;
-    for (const fn of this.#suite[phase]) {
+    for (const handler of this.#suite.phaseHandlers) {
+      if (!handler[phase]) {
+        continue;
+      }
 
       // Ensure all the criteria below are satisfied before moving forward
-      error = await Barrier.awaitOperation(TEST_PHASE_TIMEOUT, async () => fn.call(this.#suite.instance));
+      error = await Barrier.awaitOperation(TEST_PHASE_TIMEOUT, async () => handler[phase]?.(this.#suite.instance));
 
       if (error) {
-        break;
+        const toThrow = new Error(phase, { cause: error });
+        Object.assign(toThrow, { import: describeFunction(handler.constructor) ?? undefined });
+        throw toThrow;
       }
     }
-    if (error) {
-      const tbo = new TestBreakout(`[[${phase}]]`);
-      tbo.source = error;
-      throw tbo;
-    }
   }
 
   /**
@@ -65,29 +58,21 @@ export class TestPhaseManager {
   }
 
   /**
-   * On error, handle stubbing out error for the phases in progress
+   * Handles if an error occurs during a phase, ensuring that we attempt to end the phase and then return the appropriate test results for the failure
    */
-  async onError(error: Error | unknown): Promise<void> {
-    if (!(error instanceof Error)) {
-      throw error;
-    }
+  async errorPhase(phase: 'all' | 'each', error: unknown, suite: SuiteConfig, test?: TestConfig): Promise<TestResult[]> {
+    try { await this.endPhase(phase); } catch { }
+    if (!(error instanceof Error)) { throw error; }
 
-    for (const ph of this.#progress) {
-      try {
-        await this.runPhase(ph === 'all' ? 'afterAll' : 'afterEach');
-      } catch { /* Do nothing */ }
+    // Don't propagate our own errors
+    if (error.message === 'afterAll' || error.message === 'afterEach') {
+      return [];
     }
 
-    this.#progress = [];
-
-    const failure = AssertUtil.generateSuiteFailure(
-      this.#suite,
-      error instanceof TestBreakout ? error.message : 'all',
-      error instanceof TestBreakout ? error.source! : error
-    );
-
-    this.#onSuiteFailure(failure);
-    this.#result.tests[failure.testResult.methodName] = failure.testResult;
-    this.#result.failed++;
+    if (test) {
+      return [AssertUtil.generateSuiteTestFailure({ suite, error, test })];
+    } else {
+      return AssertUtil.generateSuiteTestFailures(suite, error);
+    }
   }
 }

package/src/execute/run.ts

@@ -65,7 +65,7 @@ export class RunUtil {
         }
       }
     } else {
-      for await (const match of all) {
+      for (const match of all) {
         if (await this.isTestFile(match.sourceFile)) {
           yield match.import;
         }
@@ -97,13 +97,12 @@ export class RunUtil {
       ) :
       ((): boolean => true);
 
-    const parsed: TestConfig[] = JSONUtil.parseSafe(digestProcess.stdout);
+    const parsed: TestConfig[] = JSONUtil.fromUTF8(digestProcess.stdout);
 
     const events = parsed.filter(testFilter).reduce((runs, test) => {
-      if (!runs.has(test.classId)) {
-        runs.set(test.classId, { import: test.import, classId: test.classId, methodNames: [], runId: Util.uuid(), metadata });
-      }
-      runs.get(test.classId)!.methodNames!.push(test.methodName);
+      runs.getOrInsert(test.classId,
+        { import: test.import, classId: test.classId, methodNames: [], runId: Util.uuid(), metadata }
+      ).methodNames!.push(test.methodName);
       return runs;
     }, new Map<string, TestRun>());
 
@@ -229,7 +228,7 @@ export class RunUtil {
         run => buildStandardTestManager(consumer, run),
         runs,
         {
-          idleTimeoutMillis: TimeUtil.asMillis(10, 's'),
+          idleTimeoutMillis: TimeUtil.duration('10s', 'ms'),
           min: 1,
           max: consumerConfig.concurrency
         }