@travetto/test 4.1.0 → 5.0.0-rc.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/test",
-  "version": "4.1.0",
+  "version": "5.0.0-rc.0",
   "description": "Declarative test framework",
   "keywords": [
     "unit-testing",
@@ -27,15 +27,15 @@
     "directory": "module/test"
   },
   "dependencies": {
-    "@travetto/base": "^4.1.0",
-    "@travetto/registry": "^4.1.0",
-    "@travetto/terminal": "^4.1.0",
-    "@travetto/worker": "^4.1.0",
-    "@travetto/yaml": "^4.1.0"
+    "@travetto/base": "^5.0.0-rc.0",
+    "@travetto/registry": "^5.0.0-rc.0",
+    "@travetto/terminal": "^5.0.0-rc.0",
+    "@travetto/worker": "^5.0.0-rc.0",
+    "yaml": "^2.4.5"
   },
   "peerDependencies": {
-    "@travetto/cli": "^4.1.0",
-    "@travetto/transformer": "^4.1.0"
+    "@travetto/cli": "^5.0.0-rc.0",
+    "@travetto/transformer": "^5.0.0-rc.0"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/assert/check.ts

@@ -1,19 +1,13 @@
 import assert from 'node:assert';
 
 import { RuntimeIndex } from '@travetto/manifest';
-import { ObjectUtil, AppError, ClassInstance, Class } from '@travetto/base';
+import { AppError, ClassInstance, Class } from '@travetto/base';
 
 import { ThrowableError, TestConfig, Assertion } from '../model/test';
 import { AssertCapture, CaptureAssert } from './capture';
 import { AssertUtil } from './util';
 import { ASSERT_FN_OPERATOR, OP_MAPPING } from './types';
 
-declare module 'assert' {
-  interface AssertionError {
-    toJSON(): Record<string, unknown>;
-  }
-}
-
 type StringFields<T> = {
   [K in Extract<keyof T, string>]:
   (T[K] extends string ? K : never)
@@ -30,6 +24,7 @@ export class AssertCheck {
    * @param args The arguments passed in
    */
   static check(assertion: CaptureAssert, positive: boolean, ...args: unknown[]): void {
+    /* eslint-disable @typescript-eslint/consistent-type-assertions */
     assertion.file = RuntimeIndex.getSourceFile(assertion.file);
 
     let fn = assertion.operator;
@@ -46,40 +41,31 @@ export class AssertCheck {
     // Check fn to call
     if (fn === 'fail') {
       if (args.length > 1) {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         [assertion.actual, assertion.expected, assertion.message, assertion.operator] = args as [unknown, unknown, string, string];
       } else {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         [assertion.message] = args as [string];
       }
     } else if (/throw|reject/i.test(fn)) {
       assertion.operator = fn;
       if (typeof args[1] !== 'string') {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         [, assertion.expected, assertion.message] = args as [unknown, unknown, string];
       } else {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         [, assertion.message] = args as [unknown, string];
       }
     } else if (fn === 'ok' || fn === 'assert') {
       fn = assertion.operator = 'ok';
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       [assertion.actual, assertion.message] = args as [unknown, string];
       assertion.expected = { toClean: (): string => positive ? 'truthy' : 'falsy' };
       common.state = 'should be';
     } else if (fn === 'includes') {
       assertion.operator = fn;
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       [assertion.actual, assertion.expected, assertion.message] = args as [unknown, unknown, string];
     } else if (fn === 'instanceof') {
       assertion.operator = fn;
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       [assertion.actual, assertion.expected, assertion.message] = args as [unknown, unknown, string];
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       assertion.actual = (assertion.actual as ClassInstance)?.constructor;
     } else { // Handle unknown
       assertion.operator = fn ?? '';
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       [assertion.actual, assertion.expected, assertion.message] = args as [unknown, unknown, string];
     }
 
@@ -93,36 +79,24 @@ export class AssertCheck {
         assertion.expected = AssertUtil.cleanValue(assertion.expected);
       }
 
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       const [actual, expected, message] = args as [unknown, unknown, string];
 
       // Actually run the assertion
       switch (fn) {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         case 'includes': assertFn((actual as unknown[]).includes(expected), message); break;
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         case 'test': assertFn((expected as RegExp).test(actual as string), message); break;
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         case 'instanceof': assertFn(actual instanceof (expected as Class), message); break;
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         case 'in': assertFn((actual as string) in (expected as object), message); break;
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         case 'lessThan': assertFn((actual as number) < (expected as number), message); break;
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         case 'lessThanEqual': assertFn((actual as number) <= (expected as number), message); break;
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         case 'greaterThan': assertFn((actual as number) > (expected as number), message); break;
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         case 'greaterThanEqual': assertFn((actual as number) >= (expected as number), message); break;
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         case 'ok': assertFn(...args as [unknown, string]); break;
         default:
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
           if (fn && assert[fn as keyof typeof assert]) { // Assert call
             if (/not/i.test(fn)) {
               common.state = 'should not';
             }
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
             assert[fn as 'ok'].apply(null, args as [boolean, string | undefined]);
           }
       }
@@ -144,6 +118,7 @@ export class AssertCheck {
       }
       throw err;
     }
+    /* eslint-enable @typescript-eslint/consistent-type-assertions */
   }
 
   /**
@@ -205,14 +180,15 @@ export class AssertCheck {
     shouldThrow: ThrowableError | undefined,
     assertion: CaptureAssert
   ): void {
-    if (ObjectUtil.isPrimitive(err)) {
+    if (!(err instanceof Error)) {
       err = new Error(`${err}`);
     }
     if (!(err instanceof Error)) {
       throw err;
     }
     if (positive) {
-      missed = new AppError('Error thrown, but expected no errors', 'general', {}, err.stack);
+      missed = new AppError('Error thrown, but expected no errors');
+      missed.stack = err.stack;
     }
 
     const resolvedErr = (missed && err) ?? this.checkError(shouldThrow, err);
@@ -244,8 +220,8 @@ export class AssertCheck {
     try {
       action();
       if (!positive) {
-        if (!ObjectUtil.isPrimitive(shouldThrow)) {
-          shouldThrow = shouldThrow?.name;
+        if (typeof shouldThrow === 'function') {
+          shouldThrow = shouldThrow.name;
         }
         throw (missed = new AppError(`No error thrown, but expected ${shouldThrow ?? 'an error'}`));
       }
@@ -282,8 +258,8 @@ export class AssertCheck {
         await action();
       }
       if (!positive) {
-        if (!ObjectUtil.isPrimitive(shouldThrow)) {
-          shouldThrow = shouldThrow?.name;
+        if (typeof shouldThrow === 'function') {
+          shouldThrow = shouldThrow.name;
         }
         throw (missed = new AppError(`No error thrown, but expected ${shouldThrow ?? 'an error'} `));
       }

package/src/assert/util.ts

@@ -1,7 +1,6 @@
 import util from 'node:util';
 
 import { path, RuntimeIndex, RuntimeContext } from '@travetto/manifest';
-import { Class, ClassInstance, ObjectUtil } from '@travetto/base';
 
 import { TestConfig, Assertion, TestResult } from '../model/test';
 import { SuiteConfig } from '../model/suite';
@@ -19,22 +18,25 @@ export class AssertUtil {
    * Clean a value for displaying in the output
    */
   static cleanValue(val: unknown): unknown {
-    if (isCleanable(val)) {
-      return val.toClean();
-    } else if (val === null || val === undefined
-      || (!(val instanceof RegExp) && ObjectUtil.isPrimitive(val))
-      || ObjectUtil.isPlainObject(val) || Array.isArray(val)
-    ) {
-      return JSON.stringify(val);
-    } else {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      const subV = val as (Class | ClassInstance);
-      if (subV.Ⲑid || !subV.constructor || (!subV.constructor.Ⲑid && ObjectUtil.isFunction(subV))) { // If a function, show name
-        return subV.name;
-      } else { // Else inspect
-        return util.inspect(val, false, 1).replace(/\n/g, ' ');
+    switch (typeof val) {
+      case 'object': {
+        if (isCleanable(val)) {
+          return val.toClean();
+        } else if (val === null || val.constructor === Object || Array.isArray(val) || val instanceof Date) {
+          return JSON.stringify(val);
+        }
+        break;
+      }
+      case 'undefined': case 'string': case 'number': case 'bigint': case 'boolean': return JSON.stringify(val);
+      case 'function': {
+        if (val.Ⲑid || !val.constructor) {
+          return val.name;
+        }
+        break;
       }
     }
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return util.inspect(val, false, 1).replace(/\n/g, ' ');
   }
 
   /**

package/src/consumer/error.ts

@@ -1,4 +1,4 @@
-import { TypedObject, ObjectUtil } from '@travetto/base';
+import { AppError, TypedObject } from '@travetto/base';
 
 import { TestEvent, } from '../model/event';
 
@@ -25,7 +25,7 @@ export class ErrorUtil {
         error[k] = e[k];
       }
       error.name = e.name;
-      if (ObjectUtil.hasToJSON(e)) {
+      if (e instanceof AppError) {
         Object.assign(error, e.toJSON());
       }
       error.message ||= e.message;
@@ -44,8 +44,11 @@ export class ErrorUtil {
     if (isSerialized(e)) {
       const err = new Error();
 
-      for (const k of TypedObject.keys<{ name: string }>(e)) {
-        err[k] = e[k];
+      for (const k of TypedObject.keys(e)) {
+        if (k === '$') {
+          continue;
+        }
+        err[k] = e[k]!;
       }
       err.message = e.message;
       err.stack = e.stack;

package/src/consumer/types/tap.ts

@@ -1,7 +1,7 @@
 import { RuntimeIndex } from '@travetto/manifest';
 import { Terminal } from '@travetto/terminal';
-import { ObjectUtil, TimeUtil } from '@travetto/base';
-import { YamlUtil } from '@travetto/yaml';
+import { AppError, TimeUtil } from '@travetto/base';
+import { stringify } from 'yaml';
 
 import { TestEvent } from '../../model/event';
 import { SuitesSummary, TestConsumer } from '../types';
@@ -44,7 +44,7 @@ export class TapEmitter implements TestConsumer {
    */
   logMeta(obj: Record<string, unknown>): void {
     const lineLength = this.#terminal.width - 5;
-    let body = YamlUtil.serialize(obj, { wordwrap: lineLength });
+    let body = stringify(obj, { lineWidth: lineLength });
     body = body.split('\n').map(x => `  ${x}`).join('\n');
     this.log(`---\n${this.#enhancer.objectInspect(body)}\n...`);
   }
@@ -101,9 +101,9 @@ export class TapEmitter implements TestConsumer {
 
       // Handle error
       if (test.status === 'failed') {
-        if (test.error?.stack && !test.error.stack.includes('AssertionError')) {
+        if (test.error && test.error.name !== 'AssertionError') {
           const err = ErrorUtil.deserializeError(test.error);
-          this.logMeta({ error: ObjectUtil.hasToJSON(err) ? err.toJSON() : err });
+          this.logMeta({ error: err instanceof AppError ? err.toJSON() : err });
         }
       }
 
@@ -127,8 +127,7 @@ export class TapEmitter implements TestConsumer {
     if (summary.errors.length) {
       this.log('---\n');
       for (const err of summary.errors) {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        this.log(this.#enhancer.failure(ObjectUtil.hasToJSON(err) ? err.toJSON() as string : `${err}`));
+        this.log(this.#enhancer.failure(err instanceof AppError ? JSON.stringify(err.toJSON(), null, 2) : `${err}`));
       }
     }
 
@@ -141,7 +140,7 @@ export class TapEmitter implements TestConsumer {
       `${this.#enhancer.total(summary.failed)}`,
       'skipped',
       this.#enhancer.total(summary.skipped),
-      `# (Total Test Time: ${TimeUtil.prettyDelta(summary.duration)}, Total Run Time: ${TimeUtil.prettyDeltaSinceTime(this.#start)})`
+      `# (Total Test Time: ${TimeUtil.asClock(summary.duration)}, Total Run Time: ${TimeUtil.asClock(Date.now() - this.#start)})`
     ].join(' '));
   }
 }

package/src/consumer/types/xunit.ts

@@ -1,6 +1,6 @@
 import { Writable } from 'node:stream';
 
-import { YamlUtil } from '@travetto/yaml';
+import { stringify } from 'yaml';
 
 import { TestEvent } from '../../model/event';
 import { SuitesSummary, TestConsumer } from '../types';
@@ -33,7 +33,7 @@ export class XunitEmitter implements TestConsumer {
       }
     }
     if (Object.keys(obj).length) {
-      let body = YamlUtil.serialize(obj);
+      let body = stringify(obj);
       body = body.split('\n').map(x => `  ${x}`).join('\n');
       return `<![CDATA[\n${body}\n]]>`;
     } else {

package/src/execute/console.ts

@@ -1,21 +1,23 @@
 import util from 'node:util';
 
-import { ConsoleEvent, ConsoleManager } from '@travetto/base';
+import { ConsoleEvent, ConsoleListener, ConsoleManager } from '@travetto/base';
 
 /**
  * Console capturer.  Hooks into the Console manager, and collects the
  * output into a map for test results
  */
-export class ConsoleCapture {
+export class ConsoleCapture implements ConsoleListener {
+  static #listener: ConsoleListener = ConsoleManager.get();
 
-  static out: Record<string, string[]>;
+  out: Record<string, string[]>;
 
-  static start(): void {
+  start(): this {
     this.out = {};
     ConsoleManager.set(this);
+    return this;
   }
 
-  static onLog({ level, args }: ConsoleEvent): void {
+  log({ level, args }: ConsoleEvent): void {
     (this.out[level] = this.out[level] ?? []).push(
       args
         .map((x => typeof x === 'string' ? x : util.inspect(x, false, 5)))
@@ -23,10 +25,10 @@ export class ConsoleCapture {
     );
   }
 
-  static end(): Record<string, string> {
+  end(): Record<string, string> {
     const ret = this.out ?? {};
     this.out = {};
-    ConsoleManager.clear();
+    ConsoleManager.set(ConsoleCapture.#listener);
     return Object.fromEntries(Object.entries(ret).map(([k, v]) => [k, v.join('\n')]));
   }
 }

package/src/execute/executor.ts

@@ -1,7 +1,8 @@
 import { AssertionError } from 'node:assert';
+import path from 'node:path';
 
-import { path, RuntimeIndex, RuntimeContext } from '@travetto/manifest';
-import { Env, Util } from '@travetto/base';
+import { RuntimeIndex, RuntimeContext } from '@travetto/manifest';
+import { Env, TimeUtil } from '@travetto/base';
 import { Barrier, ExecutionError } from '@travetto/worker';
 
 import { SuiteRegistry } from '../registry/suite';
@@ -12,10 +13,10 @@ import { AssertCheck } from '../assert/check';
 import { AssertCapture } from '../assert/capture';
 import { ConsoleCapture } from './console';
 import { TestPhaseManager } from './phase';
-import { PromiseCapture } from './promise';
+import { PromiseCapturer } from './promise';
 import { AssertUtil } from '../assert/util';
 
-const TEST_TIMEOUT = Env.TRV_TEST_TIMEOUT.time ?? 5000;
+const TEST_TIMEOUT = TimeUtil.fromValue(Env.TRV_TEST_TIMEOUT.val) ?? 5000;
 
 /**
  * Support execution of the tests
@@ -29,22 +30,21 @@ export class TestExecutor {
    */
   static async #executeTestMethod(test: TestConfig): Promise<Error | undefined> {
     const suite = SuiteRegistry.get(test.class);
-    const promCleanup = Util.resolvablePromise();
 
     // Ensure all the criteria below are satisfied before moving forward
     const barrier = new Barrier(test.timeout || TEST_TIMEOUT, true)
-      .add(promCleanup, true) // If not timeout or unhandled, ensure all promises are cleaned up
       .add(async () => {
         const env = process.env;
+        process.env = { ...env }; // Created an isolated environment
+        const pCap = new PromiseCapturer();
 
         try {
-          PromiseCapture.start(); // Listen for all promises to detect any unfinished, only start once method is invoked
-          process.env = { ...env }; // Created an isolated environment
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          await (suite.instance as Record<string, Function>)[test.methodName](); // Run
+          await pCap.run(() =>
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            (suite.instance as Record<string, Function>)[test.methodName]()
+          );
         } finally {
           process.env = env; // Restore
-          PromiseCapture.stop().then(() => Util.queueMacroTask().then(promCleanup.resolve), promCleanup.reject);
         }
       });
 
@@ -137,7 +137,7 @@ export class TestExecutor {
       })
     );
 
-    ConsoleCapture.start(); // Capture all output from transpiled code
+    const consoleCapture = new ConsoleCapture().start(); // Capture all output from transpiled code
 
     // Run method and get result
     let error = await this.#executeTestMethod(test);
@@ -158,7 +158,7 @@ export class TestExecutor {
 
     Object.assign(result, {
       status: error ? 'failed' : 'passed',
-      output: ConsoleCapture.end(),
+      output: consoleCapture.end(),
       assertions: getAssertions(),
       duration: Date.now() - startTime,
       ...(error ? { error } : {})

package/src/execute/phase.ts

@@ -1,5 +1,5 @@
 import { Barrier } from '@travetto/worker';
-import { Env } from '@travetto/base';
+import { Env, TimeUtil } from '@travetto/base';
 
 import { TestConsumer } from '../consumer/types';
 import { SuiteConfig, SuiteResult } from '../model/suite';
@@ -8,7 +8,7 @@ import { TestResult } from '../model/test';
 
 class TestBreakout extends Error { }
 
-const TEST_PHASE_TIMEOUT = Env.TRV_TEST_PHASE_TIMEOUT.time ?? 15000;
+const TEST_PHASE_TIMEOUT = TimeUtil.fromValue(Env.TRV_TEST_PHASE_TIMEOUT.val) ?? 15000;
 
 /**
  * Test Phase Execution Manager.

package/src/execute/promise.ts

@@ -1,72 +1,49 @@
-import { ExecutionError } from '@travetto/worker';
-
-const og = Promise;
-
-declare global {
-  interface Promise<T> {
-    status: 'ok' | 'error';
-  }
-}
+import { createHook, executionAsyncId } from 'node:async_hooks';
 
-/**
- * Promise stub to track creation
- */
-function Wrapped(this: Promise<unknown>, ex: (res: (v: unknown) => unknown, rej?: (err: unknown) => unknown) => void): Promise<unknown> {
-  const prom = new og(ex);
-  this.then = prom.then.bind(prom);
-  this.catch = prom.catch.bind(prom);
-  this.finally = prom.finally.bind(prom);
-  this.then(() => prom.status = 'ok',
-    () => prom.status = 'error');
-
-  if (PromiseCapture.pending) {
-    PromiseCapture.pending.push(prom);
-  }
-  return this;
-}
-
-Wrapped.allSettled = Promise.allSettled.bind(Promise);
-Wrapped.race = Promise.race.bind(Promise);
-Wrapped.all = Promise.all.bind(Promise);
-Wrapped.resolve = Promise.resolve.bind(Promise);
-Wrapped.reject = Promise.reject.bind(Promise);
+import { ExecutionError } from '@travetto/worker';
+import { Util } from '@travetto/base';
 
 /**
  * Promise watcher, to catch any unfinished promises
  */
-export class PromiseCapture {
-  static pending: Promise<unknown>[];
-
-  /**
-   * Swap method and track progress
-   */
-  static start(): void {
-    this.pending = [];
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    global.Promise = Wrapped as unknown as typeof Promise;
+export class PromiseCapturer {
+  #pending = new Map<number, Promise<unknown>>();
+  #id: number = 0;
+
+  #init(id: number, type: string, triggerId: number, resource: unknown): void {
+    if (this.#id && type === 'PROMISE' && triggerId === this.#id) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      this.#pending.set(id, resource as Promise<unknown>);
+    }
   }
 
-  /**
-   * Wait for all promises to resolve
-   */
-  static async resolvePending(pending: Promise<unknown>[]): Promise<void> {
-    if (pending.length) {
-      let final: Error | undefined;
-      console.debug('Resolving', { pending: this.pending.length });
-      await Promise.all(pending).catch(err => final = err);
-
-      // If any return in an error, make that the final result
-      throw new ExecutionError(`Pending promises: ${pending.length}`, final?.stack);
-    }
+  #promiseResolve(asyncId: number): void {
+    this.#pending.delete(asyncId);
   }
 
-  /**
-   * Stop the capture
-   */
-  static stop(): Promise<void> {
-    console.debug('Stopping', { pending: this.pending.length });
-    // Restore the promise
-    global.Promise = og;
-    return this.resolvePending(this.pending.filter(x => x.status === undefined));
+  async run(op: () => Promise<unknown> | unknown): Promise<unknown> {
+    const hook = createHook({
+      init: (...args) => this.#init(...args),
+      promiseResolve: (id) => this.#promiseResolve(id)
+    });
+
+    hook.enable();
+
+    await Util.queueMacroTask();
+    this.#id = executionAsyncId();
+    try {
+      const res = await op();
+      let i = 5; // Wait upto 5 macro tasks before continuing
+      while (this.#pending.size) {
+        await Util.queueMacroTask();
+        i -= 1;
+        if (i === 0) {
+          throw new ExecutionError(`Pending promises: ${this.#pending.size}`);
+        }
+      }
+      return res;
+    } finally {
+      hook.disable();
+    }
   }
 }

package/src/execute/runner.ts

@@ -1,4 +1,6 @@
-import { RuntimeContext, RuntimeIndex, path } from '@travetto/manifest';
+import path from 'node:path';
+
+import { path as mp, RuntimeContext, RuntimeIndex } from '@travetto/manifest';
 import { TimeUtil } from '@travetto/base';
 import { WorkPool } from '@travetto/worker';
 
@@ -21,7 +23,7 @@ export class Runner {
   }
 
   get patterns(): RegExp[] {
-    return this.#state.args.map(x => new RegExp(path.toPosix(x)));
+    return this.#state.args.map(x => new RegExp(mp.toPosix(x)));
   }
 
   /**
@@ -37,10 +39,10 @@ export class Runner {
     const testCount = await RunnerUtil.getTestCount(this.#state.args);
     await consumer.onStart({ testCount });
     await WorkPool.run(
-      () => buildStandardTestManager(consumer),
+      buildStandardTestManager.bind(null, consumer),
       files,
       {
-        idleTimeoutMillis: TimeUtil.timeToMs('10s'),
+        idleTimeoutMillis: TimeUtil.asMillis(10, 's'),
         min: 1,
         max: this.#state.concurrency,
       });

package/src/execute/watcher.ts

@@ -1,7 +1,6 @@
 import { RootRegistry, MethodSource } from '@travetto/registry';
 import { WorkPool, WorkQueue } from '@travetto/worker';
 import { RuntimeIndex } from '@travetto/manifest';
-import { ObjectUtil } from '@travetto/base';
 
 import { SuiteRegistry } from '../registry/suite';
 import { buildStandardTestManager } from '../worker/standard';
@@ -12,7 +11,7 @@ import { RunnerUtil } from './util';
 import { TestEvent } from '../model/event';
 
 function isRunEvent(ev: unknown): ev is RunEvent {
-  return ObjectUtil.isPlainObject(ev) && 'type' in ev && typeof ev.type === 'string' && ev.type === 'run-test';
+  return typeof ev === 'object' && !!ev && 'type' in ev && typeof ev.type === 'string' && ev.type === 'run-test';
 }
 
 export type TestWatchEvent =
@@ -88,7 +87,7 @@ export class TestWatcher {
     }
 
     await WorkPool.run(
-      () => buildStandardTestManager(consumer),
+      buildStandardTestManager.bind(null, consumer),
       itr,
       {
         idleTimeoutMillis: 120000,

package/src/fixture.ts

@@ -2,6 +2,6 @@ import { FileLoader } from '@travetto/base';
 
 export class TestFixtures extends FileLoader {
   constructor(modules: string[] = []) {
-    super(['@#test/fixtures', ...['@', ...modules.flat()].map(x => `${x}#support/fixtures`)]);
+    super(['@#test/fixtures', ...['@', ...modules.flat(), '@@'].map(x => `${x}#support/fixtures`)]);
   }
 }

package/src/worker/child.ts

@@ -1,7 +1,7 @@
 import { createWriteStream } from 'node:fs';
 
 import { RuntimeContext } from '@travetto/manifest';
-import { ConsoleManager, Env, TimeUtil, Util } from '@travetto/base';
+import { ConsoleManager, Env, Util } from '@travetto/base';
 import { ChildCommChannel } from '@travetto/worker';
 
 import { ErrorUtil } from '../consumer/error';
@@ -15,6 +15,8 @@ import { Events, RunEvent } from './types';
  */
 export class TestChildWorker extends ChildCommChannel<RunEvent> {
 
+  #done = Util.resolvablePromise();
+
   async #exec(op: () => Promise<unknown>, type: string): Promise<void> {
     try {
       await op();
@@ -36,9 +38,9 @@ export class TestChildWorker extends ChildCommChannel<RunEvent> {
       const file = RuntimeContext.toolPath(`test-worker.${process.pid}.log`);
       const stdout = createWriteStream(file, { flags: 'a' });
       const c = new console.Console({ stdout, inspectOptions: { depth: 4, colors: false } });
-      ConsoleManager.set({ onLog: (ev) => c[ev.level](process.pid, ...ev.args) });
+      ConsoleManager.set({ log: (ev) => c[ev.level](process.pid, ...ev.args) });
     } else {
-      ConsoleManager.set({ onLog: () => { } });
+      ConsoleManager.set({ log: () => { } });
     }
 
     RunnerUtil.registerCleanup('worker');
@@ -49,7 +51,7 @@ export class TestChildWorker extends ChildCommChannel<RunEvent> {
     // Let parent know the child is ready for handling commands
     this.send(Events.READY);
 
-    await Util.blockingTimeout(TimeUtil.timeToMs('10m'));
+    await this.#done.promise;
   }
 
   /**
@@ -80,11 +82,15 @@ export class TestChildWorker extends ChildCommChannel<RunEvent> {
 
     console.debug('Running', { file: event.file });
 
-    await new Runner({
-      format: 'exec',
-      mode: 'single',
-      args: [event.file!, event.class!, event.method!],
-      concurrency: 1
-    }).run();
+    try {
+      await new Runner({
+        format: 'exec',
+        mode: 'single',
+        args: [event.file!, event.class!, event.method!],
+        concurrency: 1
+      }).run();
+    } finally {
+      this.#done.resolve();
+    }
   }
 }

package/src/worker/standard.ts

@@ -2,88 +2,72 @@ import { fork } from 'node:child_process';
 
 import { RuntimeIndex } from '@travetto/manifest';
 import { Env } from '@travetto/base';
-import { ParentCommChannel, Worker } from '@travetto/worker';
+import { ParentCommChannel } from '@travetto/worker';
 
 import { Events, RunEvent } from './types';
 import { TestConsumer } from '../consumer/types';
 import { ErrorUtil } from '../consumer/error';
 import { TestEvent } from '../model/event';
 
-let i = 0;
-
-function buildEvent(ev: string): RunEvent {
-  if (ev.includes('#')) {
-    const [file, cls, method] = ev.split('#');
-    return { file, class: cls, method };
-  } else {
-    return { file: ev };
-  }
-}
-
 /**
  *  Produce a handler for the child worker
  */
-export function buildStandardTestManager(consumer: TestConsumer): Worker<string> {
-  /**
-   * Spawn a child
-   */
-  return {
-    id: i += 1,
-    active: true,
-    async destroy(): Promise<void> { },
-    async execute(file: string): Promise<void> {
-
-      process.send?.({ type: 'log', message: `Worker Executing ${file}` });
-
-      const event = buildEvent(file);
+export async function buildStandardTestManager(consumer: TestConsumer, file: string): Promise<void> {
+  process.send?.({ type: 'log', message: `Worker Executing ${file}` });
 
-      const { module } = RuntimeIndex.getEntry(event.file!)!;
-      const cwd = RuntimeIndex.getModule(module)!.sourcePath;
+  let event: RunEvent;
+  if (file.includes('#')) {
+    const [f, cls, method] = file.split('#');
+    event = { file: f, class: cls, method };
+  } else {
+    event = { file };
+  }
 
-      const channel = new ParentCommChannel<TestEvent & { error?: Error }>(
-        fork(
-          RuntimeIndex.resolveFileImport('@travetto/cli/support/entry.trv'), ['test:child'],
-          {
-            cwd,
-            env: {
-              ...process.env,
-              ...Env.TRV_MANIFEST.export(RuntimeIndex.getModule(module)!.outputPath),
-              ...Env.TRV_QUIET.export(true)
-            },
-            stdio: ['ignore', 'ignore', 2, 'ipc']
-          }
-        )
-      );
+  const { module } = RuntimeIndex.getEntry(event.file!)!;
+  const cwd = RuntimeIndex.getModule(module)!.sourcePath;
+
+  const channel = new ParentCommChannel<TestEvent & { error?: Error }>(
+    fork(
+      RuntimeIndex.resolveFileImport('@travetto/cli/support/entry.trv'), ['test:child'],
+      {
+        cwd,
+        env: {
+          ...process.env,
+          ...Env.TRV_MANIFEST.export(RuntimeIndex.getModule(module)!.outputPath),
+          ...Env.TRV_QUIET.export(true)
+        },
+        stdio: ['ignore', 'ignore', 2, 'ipc']
+      }
+    )
+  );
 
-      await channel.once(Events.READY); // Wait for the child to be ready
-      await channel.send(Events.INIT); // Initialize
-      await channel.once(Events.INIT_COMPLETE); // Wait for complete
+  await channel.once(Events.READY); // Wait for the child to be ready
+  await channel.send(Events.INIT); // Initialize
+  await channel.once(Events.INIT_COMPLETE); // Wait for complete
 
-      channel.on('*', async ev => {
-        try {
-          await consumer.onEvent(ev);  // Connect the consumer with the event stream from the child
-        } catch {
-          // Do nothing
-        }
-      });
+  channel.on('*', async ev => {
+    try {
+      await consumer.onEvent(ev);  // Connect the consumer with the event stream from the child
+    } catch {
+      // Do nothing
+    }
+  });
 
-      // Listen for child to complete
-      const complete = channel.once(Events.RUN_COMPLETE);
-      // Start test
-      channel.send(Events.RUN, event);
+  // Listen for child to complete
+  const complete = channel.once(Events.RUN_COMPLETE);
+  // Start test
+  channel.send(Events.RUN, event);
 
-      // Wait for complete
-      const { error } = await complete;
+  // Wait for complete
+  const { error } = await complete;
 
-      // Kill on complete
-      await channel.destroy();
+  // Kill on complete
+  await channel.destroy();
 
-      process.send?.({ type: 'log', message: `Worker Finished ${file}` });
+  process.send?.({ type: 'log', message: `Worker Finished ${file}` });
 
-      // If we received an error, throw it
-      if (error) {
-        throw ErrorUtil.deserializeError(error);
-      }
-    },
-  };
+  // If we received an error, throw it
+  if (error) {
+    throw ErrorUtil.deserializeError(error);
+  }
 }

package/support/cli.test.ts

@@ -1,7 +1,7 @@
 import { EventEmitter } from 'node:events';
 import fs from 'node:fs/promises';
+import path from 'node:path';
 
-import { path } from '@travetto/manifest';
 import { Env } from '@travetto/base';
 import { CliCommandShape, CliCommand, CliValidationError } from '@travetto/cli';
 import { WorkPool } from '@travetto/worker';

package/support/cli.test_child.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'node:events';
 
-import { Env, ExecUtil } from '@travetto/base';
+import { Env } from '@travetto/base';
 import { CliCommand } from '@travetto/cli';
 
 /** Test child worker target */
@@ -17,7 +17,7 @@ export class TestChildWorkerCommand {
   }
 
   async main(): Promise<void> {
-    ExecUtil.exitOnDisconnect();
+    process.once('disconnect', () => process.exit());
     const { TestChildWorker } = await import('../src/worker/child');
     return new TestChildWorker().activate();
   }