@travetto/test 3.0.0-rc.4 → 3.0.0-rc.6

package/src/consumer/types/tap.ts

@@ -1,13 +1,12 @@
-import { Writable } from 'stream';
-
-import { ColorUtil, PathUtil } from '@travetto/boot';
+import { path } from '@travetto/manifest';
+import { GlobalTerminal, Terminal } from '@travetto/terminal';
+import { ErrorUtil, ObjectUtil, TimeUtil } from '@travetto/base';
 import { YamlUtil } from '@travetto/yaml';
-import { ErrorUtil } from '@travetto/base/src/internal/error';
 
 import { TestEvent } from '../../model/event';
 import { SuitesSummary, TestConsumer } from '../types';
 import { Consumable } from '../registry';
-import { TestResultsEnhancer, COLOR_ENHANCER, DUMMY_ENHANCER } from '../enhancer';
+import { TestResultsEnhancer, CONSOLE_ENHANCER } from '../enhancer';
 
 /**
   * TAP Format consumer
@@ -15,25 +14,27 @@ import { TestResultsEnhancer, COLOR_ENHANCER, DUMMY_ENHANCER } from '../enhancer
 @Consumable('tap')
 export class TapEmitter implements TestConsumer {
   #count = 0;
-  #stream: Writable;
   #enhancer: TestResultsEnhancer;
+  #terminal: Terminal;
+  #start: number;
 
   constructor(
-    stream: Writable = process.stdout,
-    enhancer: TestResultsEnhancer = ColorUtil.colorize ? COLOR_ENHANCER : DUMMY_ENHANCER
+    terminal = new Terminal({ output: process.stdout }),
+    enhancer: TestResultsEnhancer = CONSOLE_ENHANCER
   ) {
-    this.#stream = stream;
+    this.#terminal = terminal;
     this.#enhancer = enhancer;
   }
 
-  protected log(message: string): void {
-    this.#stream.write(`${message}\n`);
+  log(message: string): void {
+    this.#terminal.writeLines(message);
   }
 
   /**
    * Preamble
    */
   onStart(): void {
+    this.#start = Date.now();
     this.log(this.#enhancer.suiteName('TAP version 13')!);
   }
 
@@ -41,7 +42,8 @@ export class TapEmitter implements TestConsumer {
    * Output supplemental data (e.g. logs)
    */
   logMeta(obj: Record<string, unknown>): void {
-    let body = YamlUtil.serialize(obj, { wordwrap: +(process.env.TRV_CONSOLE_WIDTH ?? process.stdout.columns ?? 80) - 5 });
+    const lineLength = GlobalTerminal.width - 5;
+    let body = YamlUtil.serialize(obj, { wordwrap: lineLength });
     body = body.split('\n').map(x => `  ${x}`).join('\n');
     this.log(`---\n${this.#enhancer.objectInspect(body)}\n...`);
   }
@@ -59,27 +61,29 @@ export class TapEmitter implements TestConsumer {
       }
       this.log(`# ${header}`);
 
+      const cwd = path.cwd();
+
       // Handle each assertion
       if (test.assertions.length) {
         let subCount = 0;
-        for (const a of test.assertions) {
-          const text = a.message ? `${a.text} (${this.#enhancer.failure(a.message)})` : a.text;
+        for (const asrt of test.assertions) {
+          const text = asrt.message ? `${asrt.text} (${this.#enhancer.failure(asrt.message)})` : asrt.text;
           let subMessage = [
             this.#enhancer.assertNumber(++subCount),
             '-',
             this.#enhancer.assertDescription(text),
-            `${this.#enhancer.assertFile(a.file.replace(PathUtil.cwd, '.'))}:${this.#enhancer.assertLine(a.line)}`
+            `${this.#enhancer.assertFile(asrt.file.replace(cwd, '.'))}:${this.#enhancer.assertLine(asrt.line)}`
           ].join(' ');
 
-          if (a.error) {
+          if (asrt.error) {
             subMessage = `${this.#enhancer.failure('not ok')} ${subMessage}`;
           } else {
             subMessage = `${this.#enhancer.success('ok')} ${subMessage}`;
           }
           this.log(`    ${subMessage}`);
 
-          if (a.message && a.message.length > 100) {
-            this.logMeta({ message: a.message.replace(/\\n/g, '\n') });
+          if (asrt.message && asrt.message.length > 100) {
+            this.logMeta({ message: asrt.message.replace(/\\n/g, '\n') });
           }
         }
         this.log(`    ${this.#enhancer.assertNumber(1)}..${this.#enhancer.assertNumber(subCount)}`);
@@ -100,7 +104,7 @@ export class TapEmitter implements TestConsumer {
       if (test.status === 'failed') {
         if (test.error?.stack && !test.error.stack.includes('AssertionError')) {
           const err = ErrorUtil.deserializeError(test.error);
-          this.logMeta({ error: err.toJSON?.() ?? err });
+          this.logMeta({ error: ObjectUtil.hasToJSON(err) ? err.toJSON() : err });
         }
       }
 
@@ -125,7 +129,7 @@ export class TapEmitter implements TestConsumer {
       this.log('---\n');
       for (const err of summary.errors) {
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        this.log(this.#enhancer.failure(err instanceof Error ? err.toJSON() as string : `${err}`));
+        this.log(this.#enhancer.failure(ObjectUtil.hasToJSON(err) ? err.toJSON() as string : `${err}`));
       }
     }
 
@@ -138,7 +142,7 @@ export class TapEmitter implements TestConsumer {
       `${this.#enhancer.total(summary.failed)}`,
       'skipped',
       this.#enhancer.total(summary.skipped),
-      `# (Total Time: ${summary.duration}ms)`
+      `# (Total Test Time: ${TimeUtil.prettyDelta(summary.duration)}, Total Run Time: ${TimeUtil.prettyDelta(Date.now() - this.#start)})`
     ].join(' '));
   }
 }

package/src/consumer/types.ts

@@ -26,7 +26,7 @@ export interface TestConsumer {
   /**
    * Listen for start of the test run
    */
-  onStart?(): void;
+  onStart?(files: string[]): Promise<void> | void;
   /**
    * Handle individual tests events
    */
@@ -34,5 +34,5 @@ export interface TestConsumer {
   /**
    * Summarize all results
    */
-  onSummary?(summary: SuitesSummary): void;
+  onSummary?(summary: SuitesSummary): Promise<void> | void;
 }

package/src/consumer/util.ts

@@ -1,4 +1,4 @@
-import { ErrorUtil } from '@travetto/base/src/internal/error';
+import { ErrorUtil } from '@travetto/base';
 import { TestEvent, } from '../model/event';
 
 export class ConsumerUtil {

package/src/decorator/suite.ts

@@ -1,3 +1,4 @@
+import { RootIndex } from '@travetto/manifest';
 import { Class, ClassInstance } from '@travetto/base';
 
 import { SuiteRegistry } from '../registry/suite';
@@ -8,7 +9,7 @@ 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
- * @augments `@trv:test/Suite`
+ * @augments `@travetto/test:Suite`
  */
 export function Suite(): ClassDecorator;
 export function Suite(...rest: Partial<SuiteConfig>[]): ClassDecorator;
@@ -26,7 +27,7 @@ export function Suite(description?: string | Partial<SuiteConfig>, ...rest: Part
   // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   const decorator = ((target: Class) => {
     const cfg = { description: descriptionString, ...extra };
-    if (target.ᚕabstract) {
+    if (RootIndex.getFunctionMetadata(target)?.abstract) {
       cfg.skip = true;
     }
     SuiteRegistry.register(target, cfg);

package/src/decorator/test.ts

@@ -1,12 +1,21 @@
 import { ClassInstance } from '@travetto/base';
+import { RootIndex } from '@travetto/manifest';
 
 import { SuiteRegistry } from '../registry/suite';
 import { TestConfig } from '../model/test';
 
+/**
+ * The `@AssertCheck` indicates that a function's assert calls should be transformed
+ */
+export function AssertCheck(): MethodDecorator {
+  return (inst: ClassInstance, prop: string | symbol, descriptor: PropertyDescriptor) => descriptor;
+}
+
 /**
  * The `@Test` decorator register a test to be run as part of the enclosing suite.
  * @param description The test description
- * @augments `@trv:test/Test`
+ * @augments `@travetto/test:Test`
+ * @augments `@travetto/test:AssertCheck`
  */
 export function Test(): MethodDecorator;
 export function Test(...rest: Partial<TestConfig>[]): MethodDecorator;
@@ -23,7 +32,7 @@ export function Test(description?: string | Partial<TestConfig>, ...rest: Partia
   return (inst: ClassInstance, prop: string | symbol, descriptor: PropertyDescriptor) => {
     SuiteRegistry.registerField(inst.constructor, descriptor.value, {
       ...extra,
-      file: inst.constructor.ᚕfile,
+      file: RootIndex.getFunctionMetadata(inst.constructor)!.source,
       description: descriptionString
     });
     return descriptor;

package/src/execute/console.ts

@@ -1,5 +1,6 @@
-import * as util from 'util';
-import { ConsoleManager, LogLevel } from '@travetto/base';
+import util from 'util';
+
+import { ConsoleEvent, ConsoleManager } from '@travetto/base';
 
 /**
  * Console capturer.  Hooks into the Console manager, and collects the
@@ -14,7 +15,7 @@ export class ConsoleCapture {
     ConsoleManager.set(this);
   }
 
-  static onLog(level: LogLevel, ctx: { file: string, line: number }, args: unknown[]): void {
+  static onLog({ level, args }: ConsoleEvent): void {
     (this.out[level] = this.out[level] ?? []).push(
       args
         .map((x => typeof x === 'string' ? x : util.inspect(x, false, 4)))

package/src/execute/executor.ts

@@ -1,12 +1,8 @@
-import * as path from 'path';
-import * as timers from 'timers/promises';
-import * as fs from 'fs/promises';
+import timers from 'timers/promises';
 
-import { Util } from '@travetto/base';
-import { ExecUtil, PathUtil } from '@travetto/boot';
+import { path, RootIndex } from '@travetto/manifest';
+import { TimeUtil, Util } from '@travetto/base';
 import { Barrier, ExecutionError } from '@travetto/worker';
-import { SystemUtil } from '@travetto/boot/src/internal/system';
-import { ModuleUtil } from '@travetto/boot/src/internal/module-util';
 
 import { SuiteRegistry } from '../registry/suite';
 import { TestConfig, TestResult } from '../model/test';
@@ -18,9 +14,8 @@ import { ConsoleCapture } from './console';
 import { TestPhaseManager } from './phase';
 import { PromiseCapture } from './promise';
 import { AssertUtil } from '../assert/util';
-import { TestEvent } from '../model/event';
 
-const TEST_TIMEOUT = Util.getEnvTime('TRV_TEST_TIMEOUT', '5s');
+const TEST_TIMEOUT = TimeUtil.getEnvTime('TRV_TEST_TIMEOUT', '5s');
 
 /**
  * Support execution of the tests
@@ -32,7 +27,7 @@ export class TestExecutor {
    *
    * This method should never throw under any circumstances.
    */
-  static #executeTestMethod(test: TestConfig): Promise<Error | undefined> {
+  static async #executeTestMethod(test: TestConfig): Promise<Error | undefined> {
     const suite = SuiteRegistry.get(test.class);
     const promCleanup = Util.resolvablePromise();
 
@@ -40,11 +35,15 @@ export class TestExecutor {
     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;
+
         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
         } finally {
+          process.env = env; // Restore
           PromiseCapture.stop().then(() => timers.setTimeout(1).then(promCleanup.resolve), promCleanup.reject);
         }
       });
@@ -69,10 +68,10 @@ export class TestExecutor {
    */
   static failFile(consumer: TestConsumer, file: string, err: Error): void {
     const name = path.basename(file);
-    const classId = ModuleUtil.getId(file, name);
+    const classId = RootIndex.getId(file, name);
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const suite = { class: { name }, classId, duration: 0, lines: { start: 1, end: 1 }, file, } as SuiteConfig & SuiteResult;
-    err.message = err.message.replace(PathUtil.cwd, '.');
+    err.message = err.message.replace(path.cwd(), '.');
     const res = AssertUtil.generateSuiteError(suite, 'require', err);
     consumer.onEvent({ type: 'suite', phase: 'before', suite });
     consumer.onEvent({ type: 'test', phase: 'before', test: res.testConfig });
@@ -110,6 +109,7 @@ export class TestExecutor {
 
     const result: TestResult = {
       methodName: test.methodName,
+      module: RootIndex.manifest.mainModule,
       description: test.description,
       classId: test.classId,
       lines: { ...test.lines },
@@ -138,6 +138,7 @@ export class TestExecutor {
 
     // Run method and get result
     let error = await this.#executeTestMethod(test);
+
     if (error) {
       if (error instanceof ExecutionError) { // Errors that are not expected
         AssertCheck.checkUnhandled(test, error);
@@ -197,11 +198,17 @@ export class TestExecutor {
 
     const mgr = new TestPhaseManager(consumer, suite, result);
 
+    const originalEnv = { ...process.env };
+
     try {
       // Handle the BeforeAll calls
       await mgr.startPhase('all');
 
+      const suiteEnv = { ...process.env };
+
       for (const test of suite.tests) {
+        // Reset env before each test
+        process.env = { ...suiteEnv };
         const testStart = Date.now();
         const skip = await this.#skip(test, suite.instance);
         if (!skip) {
@@ -227,6 +234,9 @@ export class TestExecutor {
       await mgr.onError(err);
     }
 
+    // Restore env
+    process.env = { ...originalEnv };
+
     result.duration = Date.now() - startTime;
 
     // Mark suite complete
@@ -242,12 +252,12 @@ export class TestExecutor {
    */
   static async execute(consumer: TestConsumer, file: string, ...args: string[]): Promise<void> {
 
-    if (!file.startsWith(PathUtil.cwd)) {
-      file = PathUtil.joinUnix(PathUtil.cwd, file);
-    }
+    file = path.resolve(file);
+
+    const entry = RootIndex.getEntry(file)!;
 
     try {
-      await import(PathUtil.toUnix(file)); // Path to module
+      await import(entry.import);
     } catch (err) {
       if (!(err instanceof Error)) {
         throw err;
@@ -275,28 +285,4 @@ export class TestExecutor {
       await this.executeSuite(consumer, params.suite);
     }
   }
-
-  /**
-   * Execute isolated
-   */
-  static async executeIsolated(consumer: TestConsumer, file: string, ...args: string[]): Promise<void> {
-    // Read modules for extensions
-    const modules = [...(await fs.readFile(file, 'utf8'))
-      .matchAll(/\/\/\s*@with-module\s+(@travetto\/[A-Za-z0-9\-]+)/g)]
-      .map(x => x[1]);
-
-    const proc = ExecUtil.forkMain(require.resolve('../../bin/test-direct'), [file, ...args], {
-      env: {
-        TRV_MODULES: modules.join(','),
-        TRV_RESOURCES: process.env.TRV_RESOURCES,
-        TRV_PROFILES: process.env.TRV_PROFILES,
-        TRV_SRC_LOCAL: '^test-isolated',
-        TRV_SRC_COMMON: process.env.TRV_SRC_COMMON,
-        TRV_TEST_FORMAT: 'exec',
-        TRV_CACHE: `.trv_cache_${SystemUtil.naiveHash(file)}`
-      }
-    });
-    proc.process.on('message', (e: TestEvent) => consumer.onEvent(e));
-    await proc.result;
-  }
 }

package/src/execute/phase.ts

@@ -1,5 +1,5 @@
 import { Barrier } from '@travetto/worker';
-import { Util } from '@travetto/base';
+import { 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 = Util.getEnvTime('TRV_TEST_PHASE_TIMEOUT', '15s');
+const TEST_PHASE_TIMEOUT = TimeUtil.getEnvTime('TRV_TEST_PHASE_TIMEOUT', '15s');
 
 /**
  * Test Phase Execution Manager.

package/src/execute/runner.ts

@@ -1,14 +1,13 @@
-import { PathUtil } from '@travetto/boot';
-import { PhaseManager, Util } from '@travetto/base';
+import { path } from '@travetto/manifest';
+import { TimeUtil } from '@travetto/base';
 import { WorkPool, IterableWorkSet } from '@travetto/worker';
 
-import { TestExecutor } from './executor';
 import { buildStandardTestManager } from '../worker/standard';
-import { buildIsolatedTestManager } from '../worker/isolated';
+import { RunnableTestConsumer } from '../consumer/types/runnable';
 
+import { TestExecutor } from './executor';
 import { RunnerUtil } from './util';
 import { RunState } from './types';
-import { RunnableTestConsumer } from '../consumer/types/runnable';
 
 /**
  * Test Runner
@@ -22,37 +21,29 @@ export class Runner {
   }
 
   get patterns(): RegExp[] {
-    return this.#state.args.map(x => new RegExp(PathUtil.toUnix(x)));
+    return this.#state.args.map(x => new RegExp(path.toPosix(x)));
   }
 
   /**
    * Run all files
    */
   async runFiles(): Promise<boolean> {
-    const consumer = RunnableTestConsumer.get(this.#state.consumer ?? this.#state.format);
-
-    const files = (await RunnerUtil.getTestFiles(this.patterns, this.#state.isolated ? 'test-isolated' : 'test'));
+    const consumer = await RunnableTestConsumer.get(this.#state.consumer ?? this.#state.format);
 
-    console.debug('Running', { files });
+    const files = (await RunnerUtil.getTestFiles(this.patterns));
 
-    await PhaseManager.run('test');
+    console.debug('Running', { files, patterns: this.patterns });
 
-    const manager = this.#state.isolated ?
-      buildIsolatedTestManager :
-      buildStandardTestManager;
+    const manager = buildStandardTestManager;
 
     const pool = new WorkPool(manager(consumer), {
-      idleTimeoutMillis: Util.timeToMs('10s'),
+      idleTimeoutMillis: TimeUtil.timeToMs('10s'),
       min: 1,
       max: this.#state.concurrency
     });
 
-    consumer.onStart();
-
-    await pool
-      .process(new IterableWorkSet(files))
-      .finally(() => pool.shutdown());
-
+    await consumer.onStart(files);
+    await pool.process(new IterableWorkSet(files));
     return consumer.summarizeAsBoolean();
   }
 
@@ -60,18 +51,12 @@ export class Runner {
    * Run a single file
    */
   async runSingle(): Promise<boolean> {
-    const consumer = RunnableTestConsumer.get(this.#state.consumer ?? this.#state.format);
-    consumer.onStart();
+    const consumer = await RunnableTestConsumer.get(this.#state.consumer ?? this.#state.format);
 
     const [file, ...args] = this.#state.args;
 
-    await PhaseManager.run('test');
-    if (this.#state.isolated) {
-      await TestExecutor.executeIsolated(consumer, file, ...args);
-    } else {
-      await TestExecutor.execute(consumer, file, ...args);
-    }
-
+    await consumer.onStart([path.resolve(file)]);
+    await TestExecutor.execute(consumer, file, ...args);
     return consumer.summarizeAsBoolean();
   }
 

package/src/execute/{types.d.ts → types.ts}

@@ -17,13 +17,13 @@ export interface RunState {
    */
   mode?: 'single' | 'watch' | 'standard';
   /**
-   * Number of test suites to run concurrently, when mode is not single
+   * Show progress to stderr
    */
-  concurrency: number;
+  showProgress?: boolean;
   /**
-   * Run in isolated mode?
+   * Number of test suites to run concurrently, when mode is not single
    */
-  isolated?: boolean;
+  concurrency: number;
   /**
    * Input arguments
    */

package/src/execute/util.ts

@@ -1,8 +1,8 @@
 import { createReadStream } from 'fs';
-import * as readline from 'readline';
+import readline from 'readline';
 
-import { ShutdownManager, Util } from '@travetto/base';
-import { SourceIndex } from '@travetto/boot/src/internal/source';
+import { ShutdownManager, TimeUtil } from '@travetto/base';
+import { RootIndex } from '@travetto/manifest';
 
 /**
  * Simple Test Utilities
@@ -12,7 +12,7 @@ export class RunnerUtil {
    * Add 50 ms to the shutdown to allow for buffers to output properly
    */
   static registerCleanup(scope: string): void {
-    ShutdownManager.onShutdown(`test.${scope}.bufferOutput`, () => Util.wait(50));
+    ShutdownManager.onShutdown(`test.${scope}.bufferOutput`, () => TimeUtil.wait(50));
   }
 
   /**
@@ -36,12 +36,12 @@ export class RunnerUtil {
   /**
    * Find all valid test files given the globs
    */
-  static async getTestFiles(globs: RegExp[], root = 'test'): Promise<string[]> {
-    const files = SourceIndex.find({ folder: root, paths: ['.'] })
-      .filter(f => globs.some(g => g.test(f.module)));
+  static async getTestFiles(globs: RegExp[]): Promise<string[]> {
+    const files = RootIndex.findTest({})
+      .filter(f => globs.some(g => g.test(f.import)));
 
     const validFiles = files
-      .map(f => this.isTestFile(f.file).then(valid => ({ file: f.file, valid })));
+      .map(f => this.isTestFile(f.source).then(valid => ({ file: f.source, valid })));
 
     return (await Promise.all(validFiles))
       .filter(x => x.valid)

package/src/execute/watcher.ts

@@ -1,13 +1,18 @@
-import * as os from 'os';
-
 import { RootRegistry, MethodSource } from '@travetto/registry';
 import { WorkPool, IterableWorkSet, ManualAsyncIterator } from '@travetto/worker';
+import { RootIndex } from '@travetto/manifest';
+import { ObjectUtil } from '@travetto/base';
+import { DynamicFileLoader } from '@travetto/base/src/internal/file-loader';
 
 import { SuiteRegistry } from '../registry/suite';
 import { buildStandardTestManager } from '../worker/standard';
-import { RunEvent } from '../worker/types';
 import { TestConsumerRegistry } from '../consumer/registry';
 import { CumulativeSummaryConsumer } from '../consumer/types/cumulative';
+import { RunEvent } from '../worker/types';
+
+function isRunEvent(ev: unknown): ev is RunEvent {
+  return ObjectUtil.isPlainObject(ev) && 'type' in ev && typeof ev.type === 'string' && ev.type === 'run-test';
+}
 
 /**
  * Test Watcher.
@@ -19,53 +24,71 @@ export class TestWatcher {
   /**
    * Start watching all test files
    */
-  static async watch(format: string): Promise<void> {
+  static async watch(format: string, runAllOnStart = true): Promise<void> {
     console.debug('Listening for changes');
 
-    const itr = new ManualAsyncIterator<RunEvent>();
+    const itr = new ManualAsyncIterator<string>();
     const src = new IterableWorkSet(itr);
 
     await SuiteRegistry.init();
     SuiteRegistry.listen(RootRegistry);
 
-    const consumer = new CumulativeSummaryConsumer(TestConsumerRegistry.getInstance(format));
+    const consumer = new CumulativeSummaryConsumer(await TestConsumerRegistry.getInstance(format));
     const pool = new WorkPool(buildStandardTestManager(consumer), {
       idleTimeoutMillis: 120000,
       min: 2,
-      max: os.cpus.length - 1
+      max: WorkPool.DEFAULT_SIZE
     });
 
     new MethodSource(RootRegistry).on(e => {
       const [cls, method] = (e.prev ?? e.curr ?? []);
-      if (!cls) {
+      if (!cls || RootIndex.getFunctionMetadata(cls)?.abstract) {
         return;
       }
       if (!method) {
-        consumer.removeClass(cls.ᚕid);
+        consumer.removeClass(cls.Ⲑid);
         return;
       }
       const conf = SuiteRegistry.getByClassAndMethod(cls, method)!;
       if (e.type !== 'removing') {
         if (conf) {
-          itr.add({
-            method: conf.methodName,
-            file: conf.file,
-            class: conf.class.name
-          }, true); // Shift to front
+          const key = `${conf.file}#${conf.class.name}#${conf.methodName}`;
+          itr.add(key, true); // Shift to front
         }
-      } else if (process.send) {
-        process.send({
+      } else {
+        process.send?.({
           type: 'removeTest',
           method: method?.name,
-          classId: cls?.ᚕid,
-          file: cls?.ᚕfile,
+          classId: cls?.Ⲑid,
+          file: RootIndex.getFunctionMetadata(cls)?.source
         });
       }
     });
 
     await RootRegistry.init();
 
-    await pool.process(src)
-      .finally(() => pool.shutdown());
+    process.send?.({ type: 'watch-init' });
+
+    process.on('message', ev => {
+      if (isRunEvent(ev)) {
+        itr.add([ev.file, ev.class, ev.method].filter(x => !!x).join('#'), true);
+      }
+    });
+
+    // Re-run all tests on file change
+    DynamicFileLoader.onLoadEvent(ev => {
+      if (ev.action === 'update') {
+        itr.add(ev.file);
+      }
+    });
+
+    if (runAllOnStart) {
+      for (const test of await RootIndex.findTest({})) {
+        await import(test.output);
+        itr.add(test.source);
+      }
+    }
+
+    await pool.process(src);
   }
 }

package/src/fixture.ts

@@ -0,0 +1,10 @@
+import { FileResourceProvider } from '@travetto/base';
+
+export class TestFixtures extends FileResourceProvider {
+  moduleFolder = 'support/fixtures';
+  mainFolder = 'test/fixtures';
+
+  constructor(paths: string[] = []) {
+    super(['@', ...paths,]);
+  }
+}

package/src/model/common.ts

@@ -5,6 +5,10 @@ export type Skip = boolean | ((instance: unknown) => boolean | Promise<boolean>)
  * Core Suite definition
  */
 export interface SuiteCore {
+  /**
+   * The module the test is declared in
+   */
+  module: string;
   /**
    * The class id
    */