@travetto/test 6.0.2 → 7.0.0-rc.1

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 `**/*` folders.  The pattern for tests is defined as as a standard glob using [Node](https://nodejs.org)'s built in globbing support.
 
 ## 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#L20) 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#L14) 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#L23) decorator.  All tests intrinsically support `async`/`await`. 
 
 A simple example would be:
 
@@ -79,9 +79,11 @@ would translate to:
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
+const Δmethod = tslib_1.__importStar(require("@travetto/schema/src/decorator/method.js"));
 const Δdebug = tslib_1.__importStar(require("@travetto/runtime/src/debug.js"));
 const Δcheck = tslib_1.__importStar(require("@travetto/test/src/assert/check.js"));
 const Δfunction = tslib_1.__importStar(require("@travetto/runtime/src/function.js"));
+const Δschema = tslib_1.__importStar(require("@travetto/schema/src/decorator/schema.js"));
 var mod_1 = ["@travetto/test", "doc/assert-example.ts"];
 const node_assert_1 = tslib_1.__importDefault(require("node:assert"));
 const test_1 = require("@travetto/test");
@@ -94,10 +96,12 @@ let SimpleTest = class SimpleTest {
     }
 };
 tslib_1.__decorate([
-    (0, test_1.Test)()
+    (0, test_1.Test)(),
+    Δmethod.Method({ returnType: {} })
 ], SimpleTest.prototype, "test", null);
 SimpleTest = tslib_1.__decorate([
-    (0, test_1.Suite)()
+    (0, test_1.Suite)(),
+    Δschema.Schema()
 ], SimpleTest);
 ```
 

package/__index__.ts

@@ -4,8 +4,10 @@ export * from './src/decorator/test.ts';
 export * from './src/model/suite.ts';
 export * from './src/model/test.ts';
 export * from './src/model/event.ts';
-export * from './src/registry/suite.ts';
+export * from './src/registry/registry-index.ts';
+export * from './src/registry/registry-adapter.ts';
 export * from './src/fixture.ts';
 export * from './src/consumer/types.ts';
+export * from './src/consumer/registry-index.ts';
 export * from './src/execute/error.ts';
 export { TestWatchEvent } from './src/worker/types.ts';

package/package.json

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

package/src/consumer/decorator.ts

@@ -0,0 +1,13 @@
+import { Class } from '@travetto/runtime';
+
+import { TestConsumerShape } from './types';
+import { TestConsumerRegistryIndex } from './registry-index';
+
+/**
+ * Registers a class a valid test consumer
+ */
+export function TestConsumer(): (cls: Class<TestConsumerShape>) => void {
+  return function (cls: Class<TestConsumerShape>): void {
+    TestConsumerRegistryIndex.getForRegister(cls).register();
+  };
+}

package/src/consumer/registry-adapter.ts

@@ -0,0 +1,43 @@
+import path from 'node:path';
+
+import { classConstruct, describeFunction, type Class } from '@travetto/runtime';
+import { RegistryAdapter } from '@travetto/registry';
+
+
+import type { TestConsumerShape, TestConsumerConfig } from './types.ts';
+
+/**
+ * Test Results Handler Registry
+ */
+export class TestConsumerRegistryAdapter implements RegistryAdapter<TestConsumerConfig> {
+  config: TestConsumerConfig;
+  #cls: Class<TestConsumerShape>;
+
+  constructor(cls: Class<TestConsumerShape>) {
+    this.#cls = cls;
+  }
+
+  register(...data: Partial<TestConsumerConfig>[]): TestConsumerConfig {
+    const desc = describeFunction(this.#cls);
+    this.config ??= {
+      cls: this.#cls,
+      type: desc.module?.includes('@travetto') ? path.basename(desc.modulePath) : desc.import
+    };
+    Object.assign(this.config, ...data);
+    return this.config;
+  }
+
+  finalize(): void {
+    // Do nothing for now
+  }
+
+  get(): TestConsumerConfig {
+    return this.config;
+  }
+
+  async instance(options?: Record<string, unknown>): Promise<TestConsumerShape> {
+    const inst = classConstruct(this.#cls);
+    await inst.setOptions?.(options);
+    return inst;
+  }
+}

package/src/consumer/registry-index.ts

@@ -0,0 +1,82 @@
+import { RuntimeIndex, type Class } from '@travetto/runtime';
+import { Registry, RegistryIndex, RegistryIndexStore } from '@travetto/registry';
+
+import type { TestConsumerShape } from './types.ts';
+import type { RunState } from '../execute/types.ts';
+import { TestConsumerRegistryAdapter } from './registry-adapter.ts';
+
+/**
+ * Test Results Handler Registry
+ */
+export class TestConsumerRegistryIndex implements RegistryIndex {
+
+  static #instance = Registry.registerIndex(this);
+
+  static getForRegister(cls: Class): TestConsumerRegistryAdapter {
+    return this.#instance.store.getForRegister(cls);
+  }
+
+  /**
+   * Get all registered types
+   */
+  static getTypes(): Promise<string[]> {
+    return this.#instance.getTypes();
+  }
+
+  /**
+   * Get a consumer instance that supports summarization
+   * @param consumer The consumer identifier or the actual consumer
+   */
+  static getInstance(state: Pick<RunState, 'consumer' | 'consumerOptions'>): Promise<TestConsumerShape> {
+    return this.#instance.getInstance(state);
+  }
+
+  #initialized: Promise<void>;
+  store = new RegistryIndexStore(TestConsumerRegistryAdapter);
+
+  /**
+   * Manual initialization when running outside of the bootstrap process
+   */
+  async #init(): Promise<void> {
+    const allFiles = RuntimeIndex.find({
+      module: m => m.name === '@travetto/test',
+      file: f => f.relativeFile.startsWith('src/consumer/types/')
+    });
+    for (const f of allFiles) {
+      await import(f.outputFile);
+    }
+    for (const cls of this.store.getClasses()) {
+      this.store.finalize(cls);
+    }
+  }
+
+  process(): void { }
+
+  /**
+   * Get types
+   */
+  async getTypes(): Promise<string[]> {
+    await (this.#initialized ??= this.#init());
+    const out: string[] = [];
+    for (const cls of this.store.getClasses()) {
+      const adapter = this.store.get(cls);
+      out.push(adapter.get().type);
+    }
+    return out;
+  }
+
+  /**
+   * Get a consumer instance that supports summarization
+   * @param consumer The consumer identifier or the actual consumer
+   */
+  async getInstance(state: Pick<RunState, 'consumer' | 'consumerOptions'>): Promise<TestConsumerShape> {
+    await (this.#initialized ??= this.#init());
+    for (const cls of this.store.getClasses()) {
+      const adapter = this.store.get(cls);
+      if (adapter.get().type === state.consumer) {
+        return adapter.instance(state.consumerOptions);
+      }
+    }
+    throw new Error(`No test consumer registered for type ${state.consumer}`);
+  }
+}

package/src/consumer/types/cumulative.ts

@@ -6,8 +6,8 @@ import type { TestConsumerShape } from '../types.ts';
 import type { TestEvent } from '../../model/event.ts';
 import type { TestResult } from '../../model/test.ts';
 import type { SuiteResult } from '../../model/suite.ts';
-import { SuiteRegistry } from '../../registry/suite.ts';
 import { DelegatingConsumer } from './delegating.ts';
+import { SuiteRegistryIndex } from '../../registry/registry-index.ts';
 
 /**
  * Cumulative Summary consumer
@@ -30,7 +30,7 @@ export class CumulativeSummaryConsumer extends DelegatingConsumer {
     // Was only loading to verify existence (TODO: double-check)
     if (existsSync(RuntimeIndex.getFromImport(test.import)!.sourceFile)) {
       (this.#state[test.classId] ??= {})[test.methodName] = test.status;
-      const SuiteCls = SuiteRegistry.getClasses().find(x => x.Ⲑid === test.classId);
+      const SuiteCls = SuiteRegistryIndex.getClasses().find(x => x.Ⲑid === test.classId);
       return SuiteCls ? this.computeTotal(SuiteCls) : this.removeClass(test.classId);
     } else {
       return this.removeClass(test.classId);
@@ -51,8 +51,8 @@ export class CumulativeSummaryConsumer extends DelegatingConsumer {
    * Compute totals
    */
   computeTotal(cls: Class): SuiteResult {
-    const suite = SuiteRegistry.get(cls);
-    const total = suite.tests.reduce((acc, x) => {
+    const suite = SuiteRegistryIndex.getConfig(cls);
+    const total = Object.values(suite.tests).reduce((acc, x) => {
       const status = this.#state[x.classId][x.methodName] ?? 'unknown';
       acc[status] += 1;
       return acc;

package/src/consumer/types/event.ts

@@ -4,7 +4,7 @@ import { Util } from '@travetto/runtime';
 
 import type { TestEvent } from '../../model/event.ts';
 import type { TestConsumerShape } from '../types.ts';
-import { TestConsumer } from '../registry.ts';
+import { TestConsumer } from '../decorator.ts';
 
 /**
  * Streams all test events a JSON payload, in an nd-json format

package/src/consumer/types/exec.ts

@@ -3,7 +3,7 @@ import { Util } from '@travetto/runtime';
 
 import type { TestEvent } from '../../model/event.ts';
 import type { TestConsumerShape } from '../types.ts';
-import { TestConsumer } from '../registry.ts';
+import { TestConsumer } from '../decorator.ts';
 
 /**
  * Triggers each event as an IPC command to a parent process

package/src/consumer/types/json.ts

@@ -1,7 +1,7 @@
 import type { Writable } from 'node:stream';
 
 import type { SuitesSummary } from '../types.ts';
-import { TestConsumer } from '../registry.ts';
+import { TestConsumer } from '../decorator.ts';
 
 /**
  * Returns the entire result set as a single JSON document

package/src/consumer/types/noop.ts

@@ -1,5 +1,5 @@
 import type { TestConsumerShape } from '../types.ts';
-import { TestConsumer } from '../registry.ts';
+import { TestConsumer } from '../decorator.ts';
 
 /**
  * Does nothing consumer

package/src/consumer/types/tap-summary.ts

@@ -5,7 +5,7 @@ import type { TestEvent } from '../../model/event.ts';
 import type { TestResult } from '../../model/test.ts';
 
 import type { SuitesSummary, TestConsumerShape, TestRunState } from '../types.ts';
-import { TestConsumer } from '../registry.ts';
+import { TestConsumer } from '../decorator.ts';
 
 import { TapEmitter } from './tap.ts';
 import { CONSOLE_ENHANCER, TestResultsEnhancer } from '../enhancer.ts';

package/src/consumer/types/tap.ts

@@ -6,7 +6,7 @@ import { TimeUtil, RuntimeIndex, hasToJSON } from '@travetto/runtime';
 
 import type { TestEvent } from '../../model/event.ts';
 import type { SuitesSummary, TestConsumerShape } from '../types.ts';
-import { TestConsumer } from '../registry.ts';
+import { TestConsumer } from '../decorator.ts';
 import { TestResultsEnhancer, CONSOLE_ENHANCER } from '../enhancer.ts';
 
 /**
@@ -91,7 +91,7 @@ export class TapEmitter implements TestConsumerShape {
         let subCount = 0;
         for (const asrt of test.assertions) {
           const text = asrt.message ? `${asrt.text} (${this.#enhancer.failure(asrt.message)})` : asrt.text;
-          const pth = `./${path.relative(process.cwd(), RuntimeIndex.getFromImport(asrt.import)!.sourceFile)}`;
+          const pth = asrt.import ? `./${path.relative(process.cwd(), RuntimeIndex.getFromImport(asrt.import)!.sourceFile)}` : '<unknown>';
           let subMessage = [
             this.#enhancer.assertNumber(++subCount),
             '-',

package/src/consumer/types/xunit.ts

@@ -6,7 +6,7 @@ import { RuntimeIndex } from '@travetto/runtime';
 
 import type { TestEvent } from '../../model/event.ts';
 import type { SuitesSummary, TestConsumerShape } from '../types.ts';
-import { TestConsumer } from '../registry.ts';
+import { TestConsumer } from '../decorator.ts';
 
 /**
  * Xunit consumer, compatible with JUnit formatters

package/src/consumer/types.ts

@@ -1,3 +1,5 @@
+import { Class } from '@travetto/runtime';
+
 import { TestEvent } from '../model/event.ts';
 import { Counts, SuiteResult } from '../model/suite.ts';
 
@@ -23,6 +25,17 @@ export type TestRunState = {
   testCount?: number;
 };
 
+/**
+ * Configuration for a test consumer
+ */
+export interface TestConsumerConfig {
+  cls: Class<TestConsumerShape>;
+  /**
+   * Consumer type key
+   */
+  type: string;
+}
+
 /**
  * A test consumer shape
  */

package/src/decorator/suite.ts

@@ -1,60 +1,74 @@
-import { castTo, Class, ClassInstance, describeFunction } from '@travetto/runtime';
+import { castTo, Class, ClassInstance, describeFunction, getClass } from '@travetto/runtime';
 
-import { SuiteRegistry } from '../registry/suite.ts';
 import { SuiteConfig } from '../model/suite.ts';
+import { SuiteRegistryIndex } from '../registry/registry-index.ts';
 
 export type SuitePhase = 'beforeAll' | 'beforeEach' | 'afterAll' | 'afterEach';
 
 /**
  * Register a class to be defined as a test suite, and a candidate for testing
  * @param description The Suite description
- * @augments `@travetto/test:Suite`
+ * @augments `@travetto/schema:Schema`
+ * @kind decorator
  */
 export function Suite(): ClassDecorator;
 export function Suite(...rest: Partial<SuiteConfig>[]): ClassDecorator;
 export function Suite(description: string, ...rest: Partial<SuiteConfig>[]): ClassDecorator;
 export function Suite(description?: string | Partial<SuiteConfig>, ...rest: Partial<SuiteConfig>[]): ClassDecorator {
-  const extra: Partial<SuiteConfig> = {};
-  const descriptionString = description && typeof description !== 'string' ?
-    Object.assign(extra, description).description :
-    description;
-
-  for (const r of rest) {
-    Object.assign(extra, r);
-  }
-
-  const dec = (target: Class): typeof target => {
-    const cfg = { description: descriptionString, ...extra };
-    if (describeFunction(target).abstract) {
-      cfg.skip = true;
-    }
-    SuiteRegistry.register(target, cfg);
-    return target;
+  const dec = (cls: Class): typeof cls => {
+    const isAbstract = describeFunction(cls).abstract;
+    SuiteRegistryIndex.getForRegister(cls).register(
+      ...(typeof description !== 'string' && description ? [description] : []),
+      ...rest,
+      ...isAbstract ? [{ skip: true }] : [],
+      ...(typeof description === 'string' ? [{ description }] : []),
+    );
+    return cls;
   };
 
   return castTo(dec);
 }
 
-function listener(phase: SuitePhase) {
-  return (inst: ClassInstance, prop: string, descriptor: PropertyDescriptor): PropertyDescriptor => {
-    SuiteRegistry.registerPendingListener(inst.constructor, descriptor.value, phase);
+/**
+ * Registers function to run before any tests are run
+ * @kind decorator
+ */
+export function BeforeAll() {
+  return (instance: ClassInstance, property: string, descriptor: PropertyDescriptor): PropertyDescriptor => {
+    SuiteRegistryIndex.getForRegister(getClass(instance)).register({ beforeAll: [descriptor.value] });
     return descriptor;
   };
 }
 
-/**
- * Registers function to run before any tests are run
- */
-export const BeforeAll = listener.bind(null, 'beforeAll');
 /**
  * Registers function to run before each test is run
+ * @kind decorator
  */
-export const BeforeEach = listener.bind(null, 'beforeEach');
+export function BeforeEach() {
+  return (instance: ClassInstance, property: string, descriptor: PropertyDescriptor): PropertyDescriptor => {
+    SuiteRegistryIndex.getForRegister(getClass(instance)).register({ beforeEach: [descriptor.value] });
+    return descriptor;
+  };
+}
+
 /**
  * Registers function to run after all tests are run
+ * @kind decorator
  */
-export const AfterAll = listener.bind(null, 'afterAll');
+export function AfterAll() {
+  return (instance: ClassInstance, property: string, descriptor: PropertyDescriptor): PropertyDescriptor => {
+    SuiteRegistryIndex.getForRegister(getClass(instance)).register({ afterAll: [descriptor.value] });
+    return descriptor;
+  };
+}
+
 /**
  * Registers function to run after each test is run
+ * @kind decorator
  */
-export const AfterEach = listener.bind(null, 'afterEach');
+export function AfterEach() {
+  return (instance: ClassInstance, property: string, descriptor: PropertyDescriptor): PropertyDescriptor => {
+    SuiteRegistryIndex.getForRegister(getClass(instance)).register({ afterEach: [descriptor.value] });
+    return descriptor;
+  };
+}

package/src/decorator/test.ts

@@ -1,36 +1,35 @@
-import { ClassInstance } from '@travetto/runtime';
+import { ClassInstance, getClass } from '@travetto/runtime';
 
-import { SuiteRegistry } from '../registry/suite.ts';
 import { TestConfig, ThrowableError } from '../model/test.ts';
+import { SuiteRegistryIndex } from '../registry/registry-index.ts';
 
 /**
  * The `@AssertCheck` indicates that a function's assert calls should be transformed
+ * @augments `@travetto/test:AssertCheck`
+ * @kind decorator
  */
 export function AssertCheck(): MethodDecorator {
-  return (inst: ClassInstance, prop: string | symbol, descriptor: PropertyDescriptor) => descriptor;
+  return (instance: ClassInstance, property: 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 `@travetto/test:Test`
+ * @augments `@travetto/schema:Method`
  * @augments `@travetto/test:AssertCheck`
  * @augments `@travetto/runtime:DebugBreak`
+ * @kind decorator
  */
 export function Test(): MethodDecorator;
 export function Test(...rest: Partial<TestConfig>[]): MethodDecorator;
 export function Test(description: string, ...rest: Partial<TestConfig>[]): MethodDecorator;
 export function Test(description?: string | Partial<TestConfig>, ...rest: Partial<TestConfig>[]): MethodDecorator {
-  const extra: Partial<TestConfig> = {};
-  const descriptionString = (description && typeof description !== 'string') ?
-    Object.assign(extra, description).description :
-    description;
-
-  for (const r of [...rest, { description: descriptionString }]) {
-    Object.assign(extra, r);
-  }
-  return (inst: ClassInstance, prop: string | symbol, descriptor: PropertyDescriptor) => {
-    SuiteRegistry.registerField(inst.constructor, descriptor.value, extra);
+  return (instance: ClassInstance, property: string | symbol, descriptor: PropertyDescriptor) => {
+    SuiteRegistryIndex.getForRegister(getClass(instance)).registerTest(property, descriptor.value,
+      ...(typeof description !== 'string' && description) ? [description] : [],
+      ...rest,
+      ...(typeof description === 'string') ? [{ description }] : []
+    );
     return descriptor;
   };
 }
@@ -38,10 +37,11 @@ export function Test(description?: string | Partial<TestConfig>, ...rest: Partia
 /**
  * Marks a method as should throw to indicate a lack of throwing is a problem
  * @param state The parameters to use for checking if the response is valid
+ * @kind decorator
  */
 export function ShouldThrow(state: ThrowableError): MethodDecorator {
-  return (inst: ClassInstance, prop: string | symbol, descriptor: PropertyDescriptor) => {
-    SuiteRegistry.registerField(inst.constructor, descriptor.value, { shouldThrow: state });
+  return (instance: ClassInstance, property: string | symbol, descriptor: PropertyDescriptor) => {
+    SuiteRegistryIndex.getForRegister(getClass(instance)).registerTest(property, descriptor.value, { shouldThrow: state });
     return descriptor;
   };
 }
@@ -49,10 +49,11 @@ export function ShouldThrow(state: ThrowableError): MethodDecorator {
 /**
  * Sets the full timeout window for a given test
  * @param ms Max time to wait
+ * @kind decorator
  */
 export function Timeout(ms: number): MethodDecorator {
-  return (inst: ClassInstance, prop: string | symbol, descriptor: PropertyDescriptor) => {
-    SuiteRegistry.registerField(inst.constructor, descriptor.value, { timeout: ms });
+  return (instance: ClassInstance, property: string | symbol, descriptor: PropertyDescriptor) => {
+    SuiteRegistryIndex.getForRegister(getClass(instance)).registerTest(property, descriptor.value, { timeout: ms });
     return descriptor;
   };
 }

package/src/execute/executor.ts

@@ -1,8 +1,8 @@
 import { AssertionError } from 'node:assert';
 
-import { Env, TimeUtil, Runtime, castTo } from '@travetto/runtime';
+import { Env, TimeUtil, Runtime, castTo, classConstruct } from '@travetto/runtime';
+import { Registry } from '@travetto/registry';
 
-import { SuiteRegistry } from '../registry/suite.ts';
 import { TestConfig, TestResult, TestRun } from '../model/test.ts';
 import { SuiteConfig, SuiteFailure, SuiteResult } from '../model/suite.ts';
 import { TestConsumerShape } from '../consumer/types.ts';
@@ -13,6 +13,7 @@ import { TestPhaseManager } from './phase.ts';
 import { AssertUtil } from '../assert/util.ts';
 import { Barrier } from './barrier.ts';
 import { ExecutionError } from './error.ts';
+import { SuiteRegistryIndex } from '../registry/registry-index.ts';
 
 const TEST_TIMEOUT = TimeUtil.fromValue(Env.TRV_TEST_TIMEOUT.val) ?? 5000;
 
@@ -55,7 +56,7 @@ export class TestExecutor {
    * This method should never throw under any circumstances.
    */
   async #executeTestMethod(test: TestConfig): Promise<Error | undefined> {
-    const suite = SuiteRegistry.get(test.class);
+    const suite = SuiteRegistryIndex.getConfig(test.class);
 
     // Ensure all the criteria below are satisfied before moving forward
     return Barrier.awaitOperation(test.timeout || TEST_TIMEOUT, async () => {
@@ -175,6 +176,9 @@ export class TestExecutor {
    * Execute an entire suite
    */
   async executeSuite(suite: SuiteConfig, tests: TestConfig[]): Promise<void> {
+
+    suite.instance = classConstruct(suite.class);
+
     if (!tests.length || await this.#shouldSkip(suite, suite.instance)) {
       return;
     }
@@ -246,15 +250,16 @@ export class TestExecutor {
       if (!(err instanceof Error)) {
         throw err;
       }
+      console.error(err);
       this.#onSuiteFailure(AssertUtil.gernerateImportFailure(run.import, err));
       return;
     }
 
     // Initialize registry (after loading the above)
-    await SuiteRegistry.init();
+    await Registry.finalizeForIndex(SuiteRegistryIndex);
 
     // Convert inbound arguments to specific tests to run
-    const suites = SuiteRegistry.getSuiteTests(run);
+    const suites = SuiteRegistryIndex.getSuiteTests(run);
     if (!suites.length) {
       console.warn('Unable to find suites for ', run);
     }

package/src/execute/runner.ts

@@ -10,7 +10,7 @@ import { TestRun } from '../model/test.ts';
 import { TestExecutor } from './executor.ts';
 import { RunnerUtil } from './util.ts';
 import { RunState } from './types.ts';
-import { TestConsumerRegistry } from '../consumer/registry.ts';
+import { TestConsumerRegistryIndex } from '../consumer/registry-index.ts';
 
 /**
  * Test Runner
@@ -27,7 +27,7 @@ export class Runner {
    * Run all files
    */
   async runFiles(globs?: string[]): Promise<boolean> {
-    const target = await TestConsumerRegistry.getInstance(this.#state);
+    const target = await TestConsumerRegistryIndex.getInstance(this.#state);
     const consumer = new RunnableTestConsumer(target);
     const tests = await RunnerUtil.getTestDigest(globs, this.#state.tags);
     const testRuns = RunnerUtil.getTestRuns(tests)
@@ -60,7 +60,7 @@ export class Runner {
       RuntimeIndex.reinitForModule(entry.module);
     }
 
-    const target = await TestConsumerRegistry.getInstance(this.#state);
+    const target = await TestConsumerRegistryIndex.getInstance(this.#state);
 
     const consumer = new RunnableTestConsumer(target)
       .withTransformer(e => {