@travetto/test 5.0.0-rc.3 → 5.0.0-rc.4

package/README.md

@@ -21,7 +21,7 @@ This module provides unit testing functionality that integrates with the framewo
 **Note**: All tests should be under the `test/.*` folders.  The pattern for tests is defined as a regex and not standard globbing.
 
 ## Definition
-A test suite is a collection of individual tests.  All test suites are classes with the [@Suite](https://github.com/travetto/travetto/tree/main/module/test/src/decorator/suite.ts#L13) decorator. Tests are defined as methods on the suite class, using the [@Test](https://github.com/travetto/travetto/tree/main/module/test/src/decorator/test.ts#L19) decorator.  All tests intrinsically support `async`/`await`. 
+A test suite is a collection of individual tests.  All test suites are classes with the [@Suite](https://github.com/travetto/travetto/tree/main/module/test/src/decorator/suite.ts#L13) decorator. Tests are defined as methods on the suite class, using the [@Test](https://github.com/travetto/travetto/tree/main/module/test/src/decorator/test.ts#L20) decorator.  All tests intrinsically support `async`/`await`. 
 
 A simple example would be:
 
@@ -79,27 +79,25 @@ would translate to:
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-const Ⲑ_util_1 = tslib_1.__importStar(require("@travetto/test/src/execute/util.js"));
+const Ⲑ_debug_1 = tslib_1.__importStar(require("@travetto/runtime/src/debug.js"));
 const Ⲑ_check_1 = tslib_1.__importStar(require("@travetto/test/src/assert/check.js"));
-const Ⲑ_decorator_1 = tslib_1.__importStar(require("@travetto/registry/src/decorator.js"));
 const Ⲑ_function_1 = tslib_1.__importStar(require("@travetto/runtime/src/function.js"));
 var ᚕm = ["@travetto/test", "doc/assert-example"];
 const node_assert_1 = tslib_1.__importDefault(require("node:assert"));
 const test_1 = require("@travetto/test");
 let SimpleTest = class SimpleTest {
-    static Ⲑinit = Ⲑ_function_1.register(SimpleTest, ᚕm, { hash: 1887908328, lines: [5, 12] }, { test: { hash: 102834457, lines: [8, 11] } }, false, false);
+    static Ⲑinit = Ⲑ_function_1.registerFunction(SimpleTest, ᚕm, { hash: 1887908328, lines: [5, 12] }, { test: { hash: 102834457, lines: [8, 11, 10] } }, false, false);
     async test() {
-        if (Ⲑ_util_1.RunnerUtil.tryDebugger)
+        if (Ⲑ_debug_1.tryDebugger)
             debugger;
         Ⲑ_check_1.AssertCheck.check({ module: ᚕm, line: 10, text: "{ size: 20, address: { state: 'VA' } }", operator: "deepStrictEqual" }, true, { size: 20, address: { state: 'VA' } }, {});
     }
 };
 tslib_1.__decorate([
-    (0, test_1.Test)({ ident: "@Test()", lineBodyStart: 10 })
+    (0, test_1.Test)()
 ], SimpleTest.prototype, "test", null);
 SimpleTest = tslib_1.__decorate([
-    Ⲑ_decorator_1.Register(),
-    (0, test_1.Suite)({ ident: "@Suite()" })
+    (0, test_1.Suite)()
 ], SimpleTest);
 ```
 

package/package.json

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

package/src/assert/capture.ts

@@ -1,11 +1,9 @@
 import { EventEmitter } from 'node:events';
-import { RuntimeIndex } from '@travetto/runtime';
 
 import { Assertion, TestConfig } from '../model/test';
 
 export interface CaptureAssert extends Partial<Assertion> {
-  module: [string, string];
-  file: string;
+  module?: [string, string];
   line: number;
   text: string;
   operator: string;
@@ -28,9 +26,9 @@ class $AssertCapture {
 
     // Emit and collect, every assertion as it occurs
     const handler = (a: CaptureAssert): void => {
-      const assrt = {
+      const assrt: Assertion = {
         ...a,
-        file: RuntimeIndex.getSourceFile(a.module),
+        import: a.import ?? a.module!.join('/'),
         classId: test.classId,
         methodName: test.methodName
       };

package/src/assert/check.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert';
 
-import { AppError, ClassInstance, Class, RuntimeIndex } from '@travetto/runtime';
+import { AppError, ClassInstance, Class } from '@travetto/runtime';
 
 import { ThrowableError, TestConfig, Assertion } from '../model/test';
 import { AssertCapture, CaptureAssert } from './capture';
@@ -23,9 +23,6 @@ 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.module);
-
     let fn = assertion.operator;
     assertion.operator = ASSERT_FN_OPERATOR[fn];
 
@@ -37,6 +34,7 @@ export class AssertCheck {
     // Invert check for negative
     const assertFn = positive ? assert : (x: unknown, msg?: string): unknown => assert(!x, msg);
 
+    /* eslint-disable @typescript-eslint/consistent-type-assertions */
     // Check fn to call
     if (fn === 'fail') {
       if (args.length > 1) {
@@ -214,8 +212,6 @@ export class AssertCheck {
   ): void {
     let missed: Error | undefined;
 
-    assertion.file = RuntimeIndex.getSourceFile(assertion.module);
-
     try {
       action();
       if (!positive) {
@@ -248,8 +244,6 @@ export class AssertCheck {
   ): Promise<void> {
     let missed: Error | undefined;
 
-    assertion.file = RuntimeIndex.getSourceFile(assertion.module);
-
     try {
       if ('then' in action) {
         await action;
@@ -273,15 +267,13 @@ export class AssertCheck {
    * Look for any unhandled exceptions
    */
   static checkUnhandled(test: TestConfig, err: Error | assert.AssertionError): void {
-    let line = AssertUtil.getPositionOfError(err, test.file).line;
+    let line = AssertUtil.getPositionOfError(err, test.import).line;
     if (line === 1) {
       line = test.lineStart;
     }
 
-    const entry = RuntimeIndex.getFromSource(test.file)!;
     AssertCapture.add({
-      module: [entry.module, entry.relativeFile],
-      file: test.file,
+      import: test.import,
       line,
       operator: 'throws',
       error: err,

package/src/assert/util.ts

@@ -1,6 +1,6 @@
 import util from 'node:util';
 
-import { Runtime } from '@travetto/runtime';
+import { Runtime, RuntimeIndex } from '@travetto/runtime';
 
 import { TestConfig, Assertion, TestResult } from '../model/test';
 import { SuiteConfig } from '../model/suite';
@@ -42,7 +42,7 @@ export class AssertUtil {
   /**
    * Determine file location for a given error and the stack trace
    */
-  static getPositionOfError(err: Error, filename: string): { file: string, line: number } {
+  static getPositionOfError(err: Error, imp: string): { import: string, line: number } {
     const cwd = Runtime.mainSourcePath;
     const lines = (err.stack ?? new Error().stack!)
       .replace(/[\\/]/g, '/')
@@ -50,6 +50,8 @@ export class AssertUtil {
       // Exclude node_modules, target self
       .filter(x => x.includes(cwd) && (!x.includes('node_modules') || x.includes('/support/')));
 
+    const filename = RuntimeIndex.getFromImport(imp)?.sourceFile!;
+
     let best = lines.filter(x => x.includes(filename))[0];
 
     if (!best) {
@@ -57,12 +59,12 @@ export class AssertUtil {
     }
 
     if (!best) {
-      return { file: filename, line: 1 };
+      return { import: imp, line: 1 };
     }
 
     const pth = best.trim().split(/\s+/g).slice(1).pop()!;
     if (!pth) {
-      return { file: filename, line: 1 };
+      return { import: imp, line: 1 };
     }
 
     const [file, lineNo] = pth
@@ -79,7 +81,7 @@ export class AssertUtil {
 
     const outFile = outFileParts.length > 1 ? outFileParts[1].replace(/^[\/]/, '') : filename;
 
-    const res = { file: outFile, line };
+    const res = { import: RuntimeIndex.getFromSource(outFile)?.import!, line };
 
     return res;
   }
@@ -88,7 +90,7 @@ export class AssertUtil {
    * Generate a suite error given a suite config, and an error
    */
   static generateSuiteError(suite: SuiteConfig, methodName: string, error: Error): { assert: Assertion, testResult: TestResult, testConfig: TestConfig } {
-    const { file, ...pos } = this.getPositionOfError(error, suite.file);
+    const { import: imp, ...pos } = this.getPositionOfError(error, suite.import);
     let line = pos.line;
 
     if (line === 1 && suite.lineStart) {
@@ -97,7 +99,7 @@ export class AssertUtil {
 
     const msg = error.message.split(/\n/)[0];
 
-    const core = { file, classId: suite.classId, methodName, module: Runtime.main.name };
+    const core = { import: imp, classId: suite.classId, methodName };
     const coreAll = { ...core, description: msg, lineStart: line, lineEnd: line, lineBodyStart: line };
 
     const assert: Assertion = {

package/src/consumer/types/cumulative.ts

@@ -1,6 +1,6 @@
 import { existsSync } from 'node:fs';
 
-import { Class } from '@travetto/runtime';
+import { Class, RuntimeIndex } from '@travetto/runtime';
 
 import { TestConsumer } from '../types';
 import { TestEvent } from '../../model/event';
@@ -28,7 +28,7 @@ export class CumulativeSummaryConsumer implements TestConsumer {
    */
   summarizeSuite(test: TestResult): SuiteResult {
     // Was only loading to verify existence (TODO: double-check)
-    if (existsSync(test.file)) {
+    if (existsSync(RuntimeIndex.getFromImport(test.import)!.sourceFile)) {
       this.#state[test.classId] = this.#state[test.classId] ?? {};
       this.#state[test.classId][test.methodName] = test.status;
       const SuiteCls = SuiteRegistry.getClasses().find(x =>
@@ -50,7 +50,7 @@ export class CumulativeSummaryConsumer implements TestConsumer {
   removeClass(clsId: string): SuiteResult {
     this.#state[clsId] = {};
     return {
-      classId: clsId, passed: 0, failed: 0, skipped: 0, total: 0, tests: [], duration: 0, file: '', lines: { start: 0, end: 0 }
+      classId: clsId, passed: 0, failed: 0, skipped: 0, total: 0, tests: [], duration: 0, import: '', lineStart: 0, lineEnd: 0
     };
   }
 
@@ -70,8 +70,9 @@ export class CumulativeSummaryConsumer implements TestConsumer {
       passed: total.passed,
       failed: total.failed,
       skipped: total.skipped,
-      file: suite.file,
-      lines: suite.lines,
+      import: suite.import,
+      lineStart: suite.lineStart,
+      lineEnd: suite.lineEnd,
       total: total.failed + total.passed,
       tests: [],
       duration: 0

package/src/consumer/types/tap.ts

@@ -1,5 +1,5 @@
 import { Terminal } from '@travetto/terminal';
-import { AppError, TimeUtil, Runtime } from '@travetto/runtime';
+import { AppError, TimeUtil, Runtime, RuntimeIndex } from '@travetto/runtime';
 import { stringify } from 'yaml';
 
 import { TestEvent } from '../../model/event';
@@ -66,11 +66,12 @@ export class TapEmitter implements TestConsumer {
         let subCount = 0;
         for (const asrt of test.assertions) {
           const text = asrt.message ? `${asrt.text} (${this.#enhancer.failure(asrt.message)})` : asrt.text;
+          const pth = RuntimeIndex.getFromImport(asrt.import)!.sourceFile.replace(Runtime.mainSourcePath, '.');
           let subMessage = [
             this.#enhancer.assertNumber(++subCount),
             '-',
             this.#enhancer.assertDescription(text),
-            `${this.#enhancer.assertFile(asrt.file.replace(Runtime.mainSourcePath, '.'))}:${this.#enhancer.assertLine(asrt.line)}`
+            `${this.#enhancer.assertFile(pth)}:${this.#enhancer.assertLine(asrt.line)}`
           ].join(' ');
 
           if (asrt.error) {

package/src/consumer/types/xunit.ts

@@ -2,6 +2,8 @@ import { Writable } from 'node:stream';
 
 import { stringify } from 'yaml';
 
+import { RuntimeIndex } from '@travetto/runtime';
+
 import { TestEvent } from '../../model/event';
 import { SuitesSummary, TestConsumer } from '../types';
 import { Consumable } from '../registry';
@@ -85,7 +87,7 @@ export class XunitEmitter implements TestConsumer {
     failures="${suite.failed}"
     errors="${suite.failed}"
     skipped="${suite.skipped}"
-    file="${suite.file}"
+    file="${RuntimeIndex.getFromImport(suite.import)!.sourceFile}"
   >
       ${testBodies.join('\n')}
       </testsuite>
@@ -101,7 +103,7 @@ export class XunitEmitter implements TestConsumer {
     this.#stream.write(`
 <?xml version="1.0" encoding="UTF-8"?>
 <testsuites
-  name="${summary.suites.length ? summary.suites[0].file : 'nameless'}"
+  name="${summary.suites.length ? RuntimeIndex.getFromImport(summary.suites[0].import)?.sourceFile : 'nameless'}"
   time="${summary.duration}"
   tests="${summary.total}"
   failures="${summary.failed}"

package/src/decorator/test.ts

@@ -15,6 +15,7 @@ export function AssertCheck(): MethodDecorator {
  * @param description The test description
  * @augments `@travetto/test:Test`
  * @augments `@travetto/test:AssertCheck`
+ * @augments `@travetto/runtime:DebugBreak`
  */
 export function Test(): MethodDecorator;
 export function Test(...rest: Partial<TestConfig>[]): MethodDecorator;

package/src/execute/executor.ts

@@ -65,11 +65,11 @@ export class TestExecutor {
   /**
    * Fail an entire file, marking the whole file as failed
    */
-  static failFile(consumer: TestConsumer, file: string, err: Error): void {
-    const name = path.basename(file);
-    const classId = `${RuntimeIndex.getEntry(file)?.id}￮${name}`;
+  static failFile(consumer: TestConsumer, imp: string, err: Error): void {
+    const name = path.basename(imp);
+    const classId = `${RuntimeIndex.getFromImport(imp)?.id}￮${name}`;
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const suite = { class: { name }, classId, duration: 0, lineStart: 1, lineEnd: 1, file, } as SuiteConfig & SuiteResult;
+    const suite = { class: { name }, classId, duration: 0, lineStart: 1, lineEnd: 1, import: imp, } as SuiteConfig & SuiteResult;
     err.message = err.message.replaceAll(Runtime.mainSourcePath, '.');
     const res = AssertUtil.generateSuiteError(suite, 'require', err);
     consumer.onEvent({ type: 'suite', phase: 'before', suite });
@@ -90,7 +90,7 @@ export class TestExecutor {
       total: 0,
       lineStart: suite.lineStart,
       lineEnd: suite.lineEnd,
-      file: suite.file,
+      import: suite.import,
       classId: suite.classId,
       duration: 0,
       tests: []
@@ -109,13 +109,12 @@ export class TestExecutor {
 
     const result: TestResult = {
       methodName: test.methodName,
-      module: Runtime.main.name,
       description: test.description,
       classId: test.classId,
       lineStart: test.lineStart,
       lineEnd: test.lineEnd,
       lineBodyStart: test.lineBodyStart,
-      file: test.file,
+      import: test.import,
       status: 'skipped',
       assertions: [],
       duration: 0,
@@ -258,19 +257,15 @@ export class TestExecutor {
   /**
    * Handle executing a suite's test/tests based on command line inputs
    */
-  static async execute(consumer: TestConsumer, file: string, ...args: string[]): Promise<void> {
-
-    file = path.resolve(file);
-
-    const entry = RuntimeIndex.getEntry(file)!;
+  static async execute(consumer: TestConsumer, imp: string, ...args: string[]): Promise<void> {
 
     try {
-      await import(entry.import);
+      await import(imp);
     } catch (err) {
       if (!(err instanceof Error)) {
         throw err;
       }
-      this.failFile(consumer, file, err);
+      this.failFile(consumer, imp, err);
       return;
     }
 
@@ -278,7 +273,7 @@ export class TestExecutor {
     await SuiteRegistry.init();
 
     // Convert inbound arguments to specific tests to run
-    const params = SuiteRegistry.getRunParams(file, ...args);
+    const params = SuiteRegistry.getRunParams(imp, ...args);
 
     // If running specific suites
     if ('suites' in params) {

package/src/execute/runner.ts

@@ -1,6 +1,5 @@
 import path from 'node:path';
 
-import { path as mp } from '@travetto/manifest';
 import { TimeUtil, Runtime, RuntimeIndex } from '@travetto/runtime';
 import { WorkPool } from '@travetto/worker';
 
@@ -22,25 +21,21 @@ export class Runner {
     this.#state = state;
   }
 
-  get patterns(): RegExp[] {
-    return this.#state.args.map(x => new RegExp(mp.toPosix(x)));
-  }
-
   /**
    * Run all files
    */
   async runFiles(): Promise<boolean> {
     const consumer = await RunnableTestConsumer.get(this.#state.consumer ?? this.#state.format);
 
-    const files = (await RunnerUtil.getTestFiles(this.patterns)).map(f => f.sourceFile);
+    const imports = await RunnerUtil.getTestImports(this.#state.args);
 
-    console.debug('Running', { files, patterns: this.patterns });
+    console.debug('Running', { imports, patterns: this.#state.args });
 
     const testCount = await RunnerUtil.getTestCount(this.#state.args);
     await consumer.onStart({ testCount });
     await WorkPool.run(
       buildStandardTestManager.bind(null, consumer),
-      files,
+      imports,
       {
         idleTimeoutMillis: TimeUtil.asMillis(10, 's'),
         min: 1,
@@ -54,17 +49,23 @@ export class Runner {
    * Run a single file
    */
   async runSingle(): Promise<boolean> {
-    const mod = RuntimeIndex.getEntry(path.resolve(this.#state.args[0]))!;
-    if (mod.module !== Runtime.main.name) {
-      RuntimeIndex.reinitForModule(mod.module);
+    let imp = RuntimeIndex.getFromImport(this.#state.args[0])?.import;
+
+    if (!imp) {
+      imp = RuntimeIndex.getFromSource(path.resolve(this.#state.args[0]))?.import;
+    }
+
+    const entry = RuntimeIndex.getFromImport(imp!)!;
+    if (entry.module !== Runtime.main.name) {
+      RuntimeIndex.reinitForModule(entry.module);
     }
 
     const consumer = await RunnableTestConsumer.get(this.#state.consumer ?? this.#state.format);
 
-    const [file, ...args] = this.#state.args;
+    const [, ...args] = this.#state.args;
 
     await consumer.onStart({});
-    await TestExecutor.execute(consumer, file, ...args);
+    await TestExecutor.execute(consumer, imp!, ...args);
     return consumer.summarizeAsBoolean();
   }
 

package/src/execute/util.ts

@@ -1,9 +1,9 @@
 import { spawn } from 'node:child_process';
 import { createReadStream } from 'node:fs';
-import readline from 'node:readline';
+import fs from 'node:fs/promises';
+import readline from 'node:readline/promises';
 
-import { Env, ExecUtil, ShutdownManager, Util, RuntimeIndex } from '@travetto/runtime';
-import type { IndexedFile } from '@travetto/manifest';
+import { Env, ExecUtil, ShutdownManager, Util, RuntimeIndex, Runtime } from '@travetto/runtime';
 
 /**
  * Simple Test Utilities
@@ -19,38 +19,45 @@ export class RunnerUtil {
   /**
    * Determine if a given file path is a valid test file
    */
-  static isTestFile(file: string): Promise<boolean> {
-    return new Promise<boolean>((resolve) => {
-      const input = createReadStream(file);
-      const reader = readline.createInterface({ input })
-        .on('line', line => {
-          if (line.includes('@Suite')) {
-            resolve(true);
-            reader.close();
-          }
-        })
-        .on('end', resolve.bind(null, false))
-        .on('close', resolve.bind(null, false));
-    });
+  static async isTestFile(file: string): Promise<boolean> {
+    const reader = readline.createInterface({ input: createReadStream(file) });
+    const state = { imp: false, suite: false };
+    for await (const line of reader) {
+      state.imp ||= line.includes('@travetto/test');
+      state.suite ||= line.includes('Suite'); // Decorator or name
+      if (state.imp && state.suite) {
+        reader.close();
+        return true;
+      }
+    }
+    return false;
   }
 
   /**
    * Find all valid test files given the globs
    */
-  static async getTestFiles(globs?: RegExp[]): Promise<IndexedFile[]> {
-    const files = RuntimeIndex.find({
+  static async getTestImports(globs?: string[]): Promise<string[]> {
+    const files = new Set<string>();
+    // Collect globs
+    if (globs) {
+      for await (const item of fs.glob(globs)) {
+        files.add(Runtime.workspaceRelative(item));
+      }
+    }
+
+    const found = RuntimeIndex.find({
       module: m => m.roles.includes('test') || m.roles.includes('std'),
       folder: f => f === 'test',
       file: f => f.role === 'test'
     })
-      .filter(f => globs?.some(g => g.test(f.sourceFile)) ?? true);
+      .filter(f => files.size === 0 || files.has(f.sourceFile));
 
-    const validFiles = files
-      .map(f => this.isTestFile(f.sourceFile).then(valid => ({ file: f, valid })));
+    const validImports = found
+      .map(f => this.isTestFile(f.sourceFile).then(valid => ({ import: f.import, valid })));
 
-    return (await Promise.all(validFiles))
+    return (await Promise.all(validImports))
       .filter(x => x.valid)
-      .map(x => x.file);
+      .map(x => x.import);
   }
 
   /**
@@ -70,11 +77,4 @@ export class RunnerUtil {
     }
     return countRes.valid ? +countRes.stdout : 0;
   }
-
-  /**
-   * Determine if we should invoke the debugger
-   */
-  static get tryDebugger(): boolean {
-    return Env.TRV_TEST_BREAK_ENTRY.isTrue;
-  }
 }

package/src/execute/watcher.ts

@@ -6,17 +6,19 @@ import { SuiteRegistry } from '../registry/suite';
 import { buildStandardTestManager } from '../worker/standard';
 import { TestConsumerRegistry } from '../consumer/registry';
 import { CumulativeSummaryConsumer } from '../consumer/types/cumulative';
-import { RunEvent } from '../worker/types';
+import { RunRequest } from '../worker/types';
 import { RunnerUtil } from './util';
 import { TestEvent } from '../model/event';
 
-function isRunEvent(ev: unknown): ev is RunEvent {
+function isRunRequest(ev: unknown): ev is RunRequest {
   return typeof ev === 'object' && !!ev && 'type' in ev && typeof ev.type === 'string' && ev.type === 'run-test';
 }
 
+type RemoveTestEvent = { type: 'removeTest', method: string, import: string, classId: string };
+
 export type TestWatchEvent =
   TestEvent |
-  { type: 'removeTest', method: string, file: string, classId: string } |
+  RemoveTestEvent |
   { type: 'ready' } |
   { type: 'log', message: string };
 
@@ -33,7 +35,7 @@ export class TestWatcher {
   static async watch(format: string, runAllOnStart = true): Promise<void> {
     console.debug('Listening for changes');
 
-    const itr = new WorkQueue<string>();
+    const itr = new WorkQueue<string | RunRequest>();
 
     await SuiteRegistry.init();
     SuiteRegistry.listen(RootRegistry);
@@ -52,7 +54,7 @@ export class TestWatcher {
       const conf = SuiteRegistry.getByClassAndMethod(cls, method)!;
       if (e.type !== 'removing') {
         if (conf) {
-          const key = `${conf.file}#${conf.class.name}#${conf.methodName}`;
+          const key = { import: conf.import, class: conf.class.name, method: conf.methodName };
           itr.add(key, true); // Shift to front
         }
       } else {
@@ -60,29 +62,29 @@ export class TestWatcher {
           type: 'removeTest',
           method: method?.name,
           classId: cls?.Ⲑid,
-          file: Runtime.getSource(cls)
-        });
+          import: Runtime.getImport(cls)
+        } satisfies RemoveTestEvent);
       }
     });
 
     // If a file is changed, but doesn't emit classes, re-run whole file
-    RootRegistry.onNonClassChanges(file => itr.add(file));
+    RootRegistry.onNonClassChanges(imp => itr.add(imp));
 
     await RootRegistry.init();
 
     process.on('message', ev => {
-      if (isRunEvent(ev)) {
+      if (isRunRequest(ev)) {
         console.debug('Manually triggered', ev);
-        itr.add([ev.file, ev.class, ev.method].filter(x => !!x).join('#'), true);
+        itr.add(ev, true);
       }
     });
 
     process.send?.({ type: 'ready' });
 
     if (runAllOnStart) {
-      for (const test of await RunnerUtil.getTestFiles()) {
-        await import(test.import);
-        itr.add(test.sourceFile);
+      for (const imp of await RunnerUtil.getTestImports()) {
+        await import(imp);
+        itr.add(imp);
       }
     }
 

package/src/model/common.ts

@@ -5,10 +5,6 @@ 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
    */
@@ -18,9 +14,9 @@ export interface SuiteCore {
    */
   description: string;
   /**
-   * It's file
+   * The import location for the suite
    */
-  file: string;
+  import: string;
   /**
    * The first line of the unit
    */

package/src/model/suite.ts

@@ -60,9 +60,9 @@ export interface SuiteResult extends Counts {
    */
   classId: string;
   /**
-   * File suite is in
+   * Import for the suite
    */
-  file: string;
+  import: string;
   /**
    * Start of the suite
    */

package/src/model/test.ts

@@ -62,9 +62,9 @@ export interface Assertion {
    */
   error?: Error;
   /**
-   * File of assertion
+   * Import of assertion
    */
-  file: string;
+  import: string;
   /**
    * Line number
    */

package/src/registry/suite.ts

@@ -20,9 +20,8 @@ class $SuiteRegistry extends MetadataRegistry<SuiteConfig, TestConfig> {
     const lines = describeFunction(cls)?.lines;
     return {
       class: cls,
-      module: Runtime.main.name,
       classId: cls.Ⲑid,
-      file: Runtime.getSource(cls),
+      import: Runtime.getImport(cls),
       lineStart: lines?.[0],
       lineEnd: lines?.[1],
       tests: [],
@@ -37,10 +36,10 @@ class $SuiteRegistry extends MetadataRegistry<SuiteConfig, TestConfig> {
     const lines = describeFunction(cls)?.methods?.[fn.name].lines;
     return {
       class: cls,
-      module: Runtime.main.name,
-      file: Runtime.getSource(cls),
+      import: Runtime.getImport(cls),
       lineStart: lines?.[0],
       lineEnd: lines?.[1],
+      lineBodyStart: lines?.[2],
       methodName: fn.name
     };
   }
@@ -93,11 +92,11 @@ class $SuiteRegistry extends MetadataRegistry<SuiteConfig, TestConfig> {
   /**
    * Get run parameters from provided input
    */
-  getRunParams(file: string, clsName?: string, method?: string): { suites: SuiteConfig[] } | { suite: SuiteConfig, test?: TestConfig } {
+  getRunParams(imp: string, clsName?: string, method?: string): { suites: SuiteConfig[] } | { suite: SuiteConfig, test?: TestConfig } {
     if (clsName && /^\d+$/.test(clsName)) { // If we only have a line number
       const line = parseInt(clsName, 10);
       const suites = this.getValidClasses()
-        .filter(cls => Runtime.getSource(cls) === file)
+        .filter(cls => Runtime.getImport(cls) === imp)
         .map(x => this.get(x)).filter(x => !x.skip);
       const suite = suites.find(x => line >= x.lineStart && line <= x.lineEnd);
 

package/src/trv.d.ts

@@ -12,9 +12,5 @@ declare global {
      * @default 5s
      */
     TRV_TEST_TIMEOUT: TimeSpan | number;
-    /**
-     * Should the test break on the first line of debugging
-     */
-    TRV_TEST_BREAK_ENTRY: boolean;
   }
 }

package/src/worker/child.ts

@@ -79,13 +79,13 @@ export class TestChildWorker extends ChildCommChannel<RunEvent> {
   async onRunCommand(event: RunEvent): Promise<void> {
     console.debug('Run');
 
-    console.debug('Running', { file: event.file });
+    console.debug('Running', { import: event.import });
 
     try {
       await new Runner({
         format: 'exec',
         mode: 'single',
-        args: [event.file!, event.class!, event.method!],
+        args: [event.import, event.class!, event.method!],
         concurrency: 1
       }).run();
     } finally {

package/src/worker/standard.ts

@@ -3,7 +3,7 @@ import { fork } from 'node:child_process';
 import { Env, RuntimeIndex } from '@travetto/runtime';
 import { ParentCommChannel } from '@travetto/worker';
 
-import { Events, RunEvent } from './types';
+import { Events, RunEvent, RunRequest } from './types';
 import { TestConsumer } from '../consumer/types';
 import { ErrorUtil } from '../consumer/error';
 import { TestEvent } from '../model/event';
@@ -11,28 +11,29 @@ import { TestEvent } from '../model/event';
 /**
  *  Produce a handler for the child worker
  */
-export async function buildStandardTestManager(consumer: TestConsumer, file: string): Promise<void> {
-  process.send?.({ type: 'log', message: `Worker Executing ${file}` });
+export async function buildStandardTestManager(consumer: TestConsumer, imp: string | RunRequest): Promise<void> {
+  process.send?.({ type: 'log', message: `Worker Executing ${imp}` });
 
   let event: RunEvent;
-  if (file.includes('#')) {
-    const [f, cls, method] = file.split('#');
-    event = { file: f, class: cls, method };
+  if (typeof imp === 'string') {
+    event = { import: imp };
+  } else if ('file' in imp) {
+    event = { import: RuntimeIndex.getFromSource(imp.file)?.sourceFile!, class: imp.class, method: imp.method };
   } else {
-    event = { file };
+    event = imp;
   }
 
-  const { module } = RuntimeIndex.getEntry(event.file!)!;
-  const cwd = RuntimeIndex.getModule(module)!.sourcePath;
+  const { module } = RuntimeIndex.getFromImport(event.import!)!;
+  const suiteMod = RuntimeIndex.getModule(module);
 
   const channel = new ParentCommChannel<TestEvent & { error?: Error }>(
     fork(
       RuntimeIndex.resolveFileImport('@travetto/cli/support/entry.trv'), ['test:child'],
       {
-        cwd,
+        cwd: suiteMod!.sourcePath,
         env: {
           ...process.env,
-          ...Env.TRV_MANIFEST.export(RuntimeIndex.getModule(module)!.outputPath),
+          ...Env.TRV_MANIFEST.export(suiteMod!.outputPath),
           ...Env.TRV_QUIET.export(true)
         },
         stdio: ['ignore', 'ignore', 2, 'ipc']
@@ -63,7 +64,7 @@ export async function buildStandardTestManager(consumer: TestConsumer, file: str
   // Kill on complete
   await channel.destroy();
 
-  process.send?.({ type: 'log', message: `Worker Finished ${file}` });
+  process.send?.({ type: 'log', message: `Worker Finished ${imp}` });
 
   // If we received an error, throw it
   if (error) {

package/src/worker/types.ts

@@ -1,8 +1,21 @@
+/**
+ * Test Run Request
+ */
+export type RunRequest = {
+  file: string;
+  class?: string;
+  method?: string;
+} | {
+  import: string;
+  class?: string;
+  method?: string;
+};
+
 /**
  * Test Run Event
  */
 export type RunEvent = {
-  file?: string;
+  import: string;
   error?: unknown;
   class?: string;
   method?: string;

package/support/cli.test_count.ts

@@ -13,15 +13,14 @@ export class TestCountCommand {
   }
 
   async main(patterns: string[]) {
-    const regexes = patterns.map(x => new RegExp(x));
-    const files = await RunnerUtil.getTestFiles(regexes);
+    const imports = await RunnerUtil.getTestImports(patterns);
 
     // Load all tests
-    for (const file of files) {
+    for (const imp of imports) {
       try {
-        await import(file.import);
+        await import(imp);
       } catch (err) {
-        console.error('Failed to import', file.sourceFile, err);
+        console.error('Failed to import', imp, err);
       }
     }
 

package/support/transformer.annotate.ts

@@ -1,103 +0,0 @@
-import ts from 'typescript';
-
-import {
-  TransformerState, DecoratorMeta, OnMethod, OnClass, CoreUtil, DecoratorUtil
-} from '@travetto/transformer';
-
-const RUN_UTIL = 'RunnerUtil';
-
-const RunUtilⲐ = Symbol.for('@travetto/test:runner');
-
-/**
- * Annotate transformation state
- */
-interface AnnotateState {
-  [RunUtilⲐ]?: ts.Expression;
-}
-
-/**
- * Annotate tests and suites for better diagnostics
- */
-export class AnnotationTransformer {
-
-
-  /**
-   * Initialize transformer state
-   */
-  static initState(state: TransformerState & AnnotateState): void {
-    if (!state[RunUtilⲐ]) {
-      const runUtil = state.importFile('@travetto/test/src/execute/util').ident;
-      state[RunUtilⲐ] = CoreUtil.createAccess(state.factory, runUtil, RUN_UTIL, 'tryDebugger');
-    }
-  }
-
-  /**
-   * Build source annotation, indicating line ranges
-   * @param state
-   * @param node
-   * @param dec
-  */
-  static buildAnnotation(state: TransformerState & AnnotateState, node: ts.Node, dec: ts.Decorator, expression: ts.CallExpression): ts.Decorator {
-    const ogN = (CoreUtil.hasOriginal(node) ? node.original : node);
-    const n = ts.isMethodDeclaration(ogN) ? ogN : undefined;
-
-    const newDec = state.factory.updateDecorator(
-      dec,
-      state.factory.createCallExpression(
-        expression.expression,
-        expression.typeArguments,
-        [
-          ...(expression.arguments ?? []),
-          state.fromLiteral({
-            ident: `@${DecoratorUtil.getDecoratorIdent(dec).text}()`,
-            lineBodyStart: CoreUtil.getRangeOf(state.source, n?.body?.statements[0])?.[0]
-          })
-        ]
-      )
-    );
-    return newDec;
-  }
-
-  @OnClass('Suite')
-  static annotateSuiteDetails(state: TransformerState & AnnotateState, node: ts.ClassDeclaration, dm?: DecoratorMeta): ts.ClassDeclaration {
-    const dec = dm?.dec;
-
-    if (dec && ts.isCallExpression(dec.expression)) {
-      const newDec = this.buildAnnotation(state, node, dec, dec.expression);
-      return state.factory.updateClassDeclaration(node,
-        DecoratorUtil.spliceDecorators(node, dec, [newDec]),
-        node.name,
-        node.typeParameters,
-        node.heritageClauses,
-        node.members
-      );
-    }
-    return node;
-  }
-
-  @OnMethod('Test')
-  static annotateTestDetails(state: TransformerState & AnnotateState, node: ts.MethodDeclaration, dm?: DecoratorMeta): ts.MethodDeclaration {
-    this.initState(state);
-
-    const dec = dm?.dec;
-
-    if (dec && ts.isCallExpression(dec.expression)) {
-      const newDec = this.buildAnnotation(state, node, dec, dec.expression);
-      return state.factory.updateMethodDeclaration(node,
-        DecoratorUtil.spliceDecorators(node, dec, [newDec]),
-        node.asteriskToken,
-        node.name,
-        node.questionToken,
-        node.typeParameters,
-        node.parameters,
-        node.type,
-        node.body ? state.factory.updateBlock(node.body, [
-          state.factory.createIfStatement(state[RunUtilⲐ]!,
-            state.factory.createExpressionStatement(state.factory.createIdentifier('debugger'))),
-          ...node.body.statements
-        ]) : node.body
-      );
-    }
-    return node;
-  }
-}