@travetto/test 5.0.16 → 5.0.17

package/README.md

@@ -79,18 +79,18 @@ would translate to:
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-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 Ⲑ_function_1 = tslib_1.__importStar(require("@travetto/runtime/src/function.js"));
-var ᚕm = ["@travetto/test", "doc/assert-example.ts"];
+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"));
+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");
 let SimpleTest = class SimpleTest {
-    static Ⲑinit = Ⲑ_function_1.registerFunction(SimpleTest, ᚕm, { hash: 1887908328, lines: [5, 12] }, { test: { hash: 102834457, lines: [8, 11, 10] } }, false, false);
+    static { Δfunction.registerFunction(SimpleTest, mod_1, { hash: 1887908328, lines: [5, 12] }, { test: { hash: 102834457, lines: [8, 11, 10] } }, false); }
     async test() {
-        if (Ⲑ_debug_1.tryDebugger)
+        if (Δdebug.tryDebugger)
             debugger;
-        Ⲑ_check_1.AssertCheck.check({ module: ᚕm, line: 10, text: "{ size: 20, address: { state: 'VA' } }", operator: "deepStrictEqual" }, true, { size: 20, address: { state: 'VA' } }, {});
+        Δcheck.AssertCheck.check({ module: mod_1, line: 10, text: "{ size: 20, address: { state: 'VA' } }", operator: "deepStrictEqual" }, true, { size: 20, address: { state: 'VA' } }, {});
     }
 };
 tslib_1.__decorate([
@@ -224,11 +224,12 @@ $ trv test --help
 Usage: test [options] [first:string] [globs...:string]
 
 Options:
-  -f, --format <string>         Output format for test results (default: "tap")
-  -c, --concurrency <number>    Number of tests to run concurrently (default: 4)
-  -m, --mode <single|standard>  Test run mode (default: "standard")
-  -t, --tags <string>           Tags to target or exclude
-  -h, --help                    display help for command
+  -f, --format <string>          Output format for test results (default: "tap")
+  -c, --concurrency <number>     Number of tests to run concurrently (default: 9)
+  -m, --mode <single|standard>   Test run mode (default: "standard")
+  -t, --tags <string>            Tags to target or exclude
+  -o, --format-options <string>  Format options
+  -h, --help                     display help for command
 ```
 
 The regexes are the patterns of tests you want to run, and all tests must be found under the `test/` folder.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/test",
-  "version": "5.0.16",
+  "version": "5.0.17",
   "description": "Declarative test framework",
   "keywords": [
     "unit-testing",
@@ -27,15 +27,15 @@
     "directory": "module/test"
   },
   "dependencies": {
-    "@travetto/registry": "^5.0.14",
-    "@travetto/runtime": "^5.0.14",
-    "@travetto/terminal": "^5.0.16",
-    "@travetto/worker": "^5.0.16",
+    "@travetto/registry": "^5.0.15",
+    "@travetto/runtime": "^5.0.15",
+    "@travetto/terminal": "^5.0.17",
+    "@travetto/worker": "^5.0.17",
     "yaml": "^2.6.1"
   },
   "peerDependencies": {
-    "@travetto/cli": "^5.0.17",
-    "@travetto/transformer": "^5.0.11"
+    "@travetto/cli": "^5.0.18",
+    "@travetto/transformer": "^5.0.12"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/assert/util.ts

@@ -120,7 +120,7 @@ export class AssertUtil {
    */
   static gernerateImportFailure(imp: string, err: Error): SuiteFailure {
     const name = path.basename(imp);
-    const classId = `${RuntimeIndex.getFromImport(imp)?.id}￮${name}`;
+    const classId = `${RuntimeIndex.getFromImport(imp)?.id}#${name}`;
     const suite = asFull<SuiteConfig & SuiteResult>({
       class: asFull<Class>({ name }), classId, duration: 0, lineStart: 1, lineEnd: 1, import: imp
     });

package/src/consumer/registry.ts

@@ -1,12 +1,13 @@
-import { classConstruct, type Class } from '@travetto/runtime';
-import { TestConsumer } from './types';
+import path from 'path';
+import { classConstruct, describeFunction, RuntimeIndex, type Class } from '@travetto/runtime';
+import type { TestConsumerShape } from './types';
+import { RunState } from '../execute/types';
 
 /**
  * Test Results Handler Registry
  */
 class $TestConsumerRegistry {
-  #registered = new Map<string, Class<TestConsumer>>();
-  #primary: Class<TestConsumer>;
+  #registered = new Map<string, Class<TestConsumerShape>>();
 
   /**
    * Manual initialization when running outside of the bootstrap process
@@ -15,38 +16,48 @@ class $TestConsumerRegistry {
     await import('./types/all');
   }
 
+  /**
+   * Import a specific path and load all consumers there
+   */
+  async importConsumers(pth: string): Promise<void> {
+    await import((RuntimeIndex.getEntry(pth) ?? RuntimeIndex.getFromImport(pth))!.outputFile);
+  }
+
   /**
    * Add a new consumer
-   * @param type The consumer unique identifier
    * @param cls The consumer class
-   * @param isDefault Set as the default consumer
    */
-  add(type: string, cls: Class<TestConsumer>, isDefault = false): void {
-    if (isDefault) {
-      this.#primary = cls;
-    }
-    this.#registered.set(type, cls);
+  add(cls: Class<TestConsumerShape>): void {
+    const desc = describeFunction(cls);
+    const key = desc.module?.includes('@travetto') ? path.basename(desc.modulePath) : desc.import;
+    this.#registered.set(key, cls);
   }
 
   /**
    * Retrieve a registered consumer
    * @param type The unique identifier
    */
-  get(type: string): Class<TestConsumer> {
+  get(type: string): Class<TestConsumerShape> {
     return this.#registered.get(type)!;
   }
 
+  /**
+   * Get types
+   */
+  getTypes(): string[] {
+    return [...this.#registered.keys()];
+  }
+
   /**
    * Get a consumer instance that supports summarization
    * @param consumer The consumer identifier or the actual consumer
    */
-  async getInstance(consumer: string | TestConsumer): Promise<TestConsumer> {
+  async getInstance(state: Pick<RunState, 'consumer' | 'consumerOptions'>): Promise<TestConsumerShape> {
     // TODO: Fix consumer registry init
     await this.manualInit();
-
-    return typeof consumer === 'string' ?
-      classConstruct(this.get(consumer) ?? this.#primary) :
-      consumer;
+    const inst = classConstruct(this.get(state.consumer));
+    await inst.setOptions?.(state.consumerOptions ?? {});
+    return inst;
   }
 }
 
@@ -54,11 +65,9 @@ export const TestConsumerRegistry = new $TestConsumerRegistry();
 
 /**
  * Registers a class a valid test consumer
- * @param type The unique identifier for the consumer
- * @param isDefault Is this the default consumer.  Last one wins
  */
-export function Consumable(type: string, isDefault = false): (cls: Class<TestConsumer>) => void {
-  return function (cls: Class<TestConsumer>): void {
-    TestConsumerRegistry.add(type, cls, isDefault);
+export function TestConsumer(): (cls: Class<TestConsumerShape>) => void {
+  return function (cls: Class<TestConsumerShape>): void {
+    TestConsumerRegistry.add(cls);
   };
 }

package/src/consumer/serialize.ts

@@ -1,8 +1,6 @@
 import { AppError, hasToJSON } from '@travetto/runtime';
-
 import { TestEvent, } from '../model/event';
 
-
 export type SerializedError = { [K in keyof Error]: Error[K] extends Function ? never : Error[K] } & { $: true };
 
 function isError(e: unknown): e is SerializedError {

package/src/consumer/types/all.ts

@@ -1,6 +1,6 @@
 import './cumulative';
 import './event';
-import './execution';
+import './exec';
 import './json';
 import './noop';
 import './runnable';

package/src/consumer/types/cumulative.ts

@@ -1,11 +1,11 @@
 import { existsSync } from 'node:fs';
 
-import { Class, RuntimeIndex } from '@travetto/runtime';
+import { type Class, RuntimeIndex } from '@travetto/runtime';
 
-import { TestConsumer } from '../types';
-import { TestEvent } from '../../model/event';
-import { TestResult } from '../../model/test';
-import { SuiteResult } from '../../model/suite';
+import type { TestConsumerShape } from '../types';
+import type { TestEvent } from '../../model/event';
+import type { TestResult } from '../../model/test';
+import type { SuiteResult } from '../../model/suite';
 import { SuiteRegistry } from '../../registry/suite';
 import { DelegatingConsumer } from './delegating';
 
@@ -18,7 +18,7 @@ export class CumulativeSummaryConsumer extends DelegatingConsumer {
    */
   #state: Record<string, Record<string, TestResult['status']>> = {};
 
-  constructor(target: TestConsumer) {
+  constructor(target: TestConsumerShape) {
     super([target]);
   }
 

package/src/consumer/types/delegating.ts

@@ -1,15 +1,15 @@
-import { SuitesSummary, TestConsumer, TestRunState } from '../types';
-import { TestEvent } from '../../model/event';
+import type { SuitesSummary, TestConsumerShape, TestRunState } from '../types';
+import type { TestEvent } from '../../model/event';
 
 /**
  * Delegating event consumer
  */
-export abstract class DelegatingConsumer implements TestConsumer {
-  #consumers: TestConsumer[];
+export abstract class DelegatingConsumer implements TestConsumerShape {
+  #consumers: TestConsumerShape[];
   #transformer?: (ev: TestEvent) => typeof ev;
   #filter?: (ev: TestEvent) => boolean;
 
-  constructor(consumers: TestConsumer[]) {
+  constructor(consumers: TestConsumerShape[]) {
     this.#consumers = consumers;
     for (const c of consumers) {
       c.onEvent = c.onEvent.bind(c);

package/src/consumer/types/event.ts

@@ -1,15 +1,15 @@
 import { Writable } from 'node:stream';
 
-import { TestEvent } from '../../model/event';
-import { TestConsumer } from '../types';
+import type { TestEvent } from '../../model/event';
+import type { TestConsumerShape } from '../types';
 import { SerializeUtil } from '../serialize';
-import { Consumable } from '../registry';
+import { TestConsumer } from '../registry';
 
 /**
  * Streams all test events a JSON payload, in an nd-json format
  */
-@Consumable('event')
-export class EventStreamer implements TestConsumer {
+@TestConsumer()
+export class EventStreamer implements TestConsumerShape {
   #stream: Writable;
 
   constructor(stream: Writable = process.stdout) {

package/src/consumer/types/{execution.ts → exec.ts}

@@ -1,15 +1,15 @@
 import { IpcChannel } from '@travetto/worker';
 
-import { TestEvent } from '../../model/event';
-import { TestConsumer } from '../types';
+import type { TestEvent } from '../../model/event';
+import type { TestConsumerShape } from '../types';
 import { SerializeUtil } from '../serialize';
-import { Consumable } from '../registry';
+import { TestConsumer } from '../registry';
 
 /**
  * Triggers each event as an IPC command to a parent process
  */
-@Consumable('exec')
-export class ExecutionEmitter extends IpcChannel<TestEvent> implements TestConsumer {
+@TestConsumer()
+export class ExecutionEmitter extends IpcChannel<TestEvent> implements TestConsumerShape {
   onEvent(event: TestEvent): void {
     this.send(event.type, JSON.parse(SerializeUtil.serializeToJSON(event)));
   }

package/src/consumer/types/json.ts

@@ -1,14 +1,14 @@
-import { Writable } from 'node:stream';
+import type { Writable } from 'node:stream';
 
-import { TestEvent } from '../../model/event';
-import { SuitesSummary, TestConsumer } from '../types';
-import { Consumable } from '../registry';
+import type { TestEvent } from '../../model/event';
+import type { SuitesSummary } from '../types';
+import { TestConsumer } from '../registry';
 
 /**
  * Returns the entire result set as a single JSON document
  */
-@Consumable('json')
-export class JSONEmitter implements TestConsumer {
+@TestConsumer()
+export class JSONEmitter {
 
   #stream: Writable;
 

package/src/consumer/types/noop.ts

@@ -1,11 +1,11 @@
-import { TestEvent } from '../../model/event';
-import { TestConsumer } from '../types';
-import { Consumable } from '../registry';
+import type { TestEvent } from '../../model/event';
+import type { TestConsumerShape } from '../types';
+import { TestConsumer } from '../registry';
 
 /**
  * Does nothing consumer
  */
-@Consumable('noop', true)
-export class NoopConsumer implements TestConsumer {
+@TestConsumer()
+export class NoopConsumer implements TestConsumerShape {
   onEvent(event: TestEvent): void { }
 }

package/src/consumer/types/runnable.ts

@@ -1,23 +1,16 @@
-import { TestConsumer } from '../types';
+import type { TestConsumerShape } from '../types';
 import { TestResultsSummarizer } from './summarizer';
-import { TestConsumerRegistry } from '../registry';
-import { TestEvent } from '../../model/event';
+import type { TestEvent } from '../../model/event';
 import { DelegatingConsumer } from './delegating';
 
 /**
  * Test consumer with support for multiple nested consumers, and summarization
  */
 export class RunnableTestConsumer extends DelegatingConsumer {
-  /**
-   * Build a runnable test consumer given a format or a full consumer
-   */
-  static async get(consumer: string | TestConsumer): Promise<RunnableTestConsumer> {
-    return new RunnableTestConsumer([await TestConsumerRegistry.getInstance(consumer)]);
-  }
 
   #results?: TestResultsSummarizer;
 
-  constructor(consumers: TestConsumer[]) {
+  constructor(...consumers: TestConsumerShape[]) {
     super(consumers);
     this.#results = consumers.find(x => !!x.onSummary) ? new TestResultsSummarizer() : undefined;
   }

package/src/consumer/types/summarizer.ts

@@ -1,11 +1,11 @@
-import { SuiteResult } from '../../model/suite';
-import { TestEvent } from '../../model/event';
-import { SuitesSummary, TestConsumer } from '../types';
+import type { SuiteResult } from '../../model/suite';
+import type { TestEvent } from '../../model/event';
+import type { SuitesSummary, TestConsumerShape } from '../types';
 
 /**
  * Test Result Collector, combines all results into a single Suite Result
  */
-export class TestResultsSummarizer implements TestConsumer {
+export class TestResultsSummarizer implements TestConsumerShape {
 
   summary: SuitesSummary = {
     passed: 0,

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

@@ -1,30 +1,48 @@
 import { Util, AsyncQueue } from '@travetto/runtime';
 import { StyleUtil, Terminal, TerminalUtil } from '@travetto/terminal';
 
-import { TestEvent } from '../../model/event';
-import { TestResult } from '../../model/test';
+import type { TestEvent } from '../../model/event';
+import type { TestResult } from '../../model/test';
 
-import { SuitesSummary, TestConsumer, TestRunState } from '../types';
-import { Consumable } from '../registry';
+import type { SuitesSummary, TestConsumerShape, TestRunState } from '../types';
+import { TestConsumer } from '../registry';
 
 import { TapEmitter } from './tap';
 
+type Result = {
+  key: string;
+  duration: number;
+  tests: number;
+};
+
 /**
  * Streamed summary results
  */
-@Consumable('tap-streamed')
-export class TapStreamedEmitter implements TestConsumer {
+@TestConsumer()
+export class TapStreamedEmitter implements TestConsumerShape {
+
+  #timings = new Map([
+    ['file', new Map<string, Result>()],
+    ['module', new Map<string, Result>()],
+    ['suite', new Map<string, Result>()],
+    ['test', new Map<string, Result>()],
+  ] as const);
 
   #terminal: Terminal;
   #results = new AsyncQueue<TestResult>();
   #progress: Promise<unknown> | undefined;
   #consumer: TapEmitter;
+  #options?: Record<string, unknown>;
 
   constructor(terminal: Terminal = new Terminal(process.stderr)) {
     this.#terminal = terminal;
     this.#consumer = new TapEmitter(this.#terminal);
   }
 
+  setOptions(options?: Record<string, unknown>): Promise<void> | void {
+    this.#options = options;
+  }
+
   async onStart(state: TestRunState): Promise<void> {
     this.#consumer.onStart();
 
@@ -55,6 +73,38 @@ export class TapStreamedEmitter implements TestConsumer {
       if (test.status === 'failed') {
         this.#consumer.onEvent(ev);
       }
+      const tests = this.#timings.get('test')!;
+      tests.set(`${ev.test.classId}/${ev.test.methodName}`, {
+        key: `${ev.test.classId}/${ev.test.methodName}`,
+        duration: test.duration,
+        tests: 1
+      });
+    } else if (ev.type === 'suite' && ev.phase === 'after') {
+      const [module] = ev.suite.classId.split(/:/);
+      const [file] = ev.suite.classId.split(/#/);
+
+      const modules = this.#timings.get('module')!;
+      const files = this.#timings.get('file')!;
+      const suites = this.#timings.get('suite')!;
+
+      if (!modules!.has(module)) {
+        modules.set(module, { key: module, duration: 0, tests: 0 });
+      }
+
+      if (!files.has(file)) {
+        files.set(file, { key: file, duration: 0, tests: 0 });
+      }
+
+      suites.set(ev.suite.classId, {
+        key: ev.suite.classId,
+        duration: ev.suite.duration,
+        tests: ev.suite.tests.length
+      });
+
+      files.get(file)!.duration += ev.suite.duration;
+      files.get(file)!.tests += ev.suite.tests.length;
+      modules.get(module)!.duration += ev.suite.duration;
+      modules.get(module)!.tests += ev.suite.tests.length;
     }
   }
 
@@ -65,5 +115,21 @@ export class TapStreamedEmitter implements TestConsumer {
     this.#results.close();
     await this.#progress;
     await this.#consumer.onSummary?.(summary);
+
+    const enhancer = this.#consumer.enhancer;
+
+    if (this.#options?.timings) {
+      const count = +(this.#options?.count ?? 5);
+      console.log('\n---');
+      for (const [title, results] of [...this.#timings.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
+        console.log(`${enhancer.suiteName(`Top ${count} slowest ${title}s`)}: `);
+        const top10 = [...results.values()].sort((a, b) => b.duration - a.duration).slice(0, count);
+        for (const x of top10) {
+          console.log(`  * ${enhancer.testName(x.key)} - ${enhancer.total(x.duration)}ms / ${enhancer.total(x.tests)} tests`);
+        }
+        console.log();
+      }
+      console.log('...');
+    }
   }
 }

package/src/consumer/types/tap.ts

@@ -3,17 +3,17 @@ import { stringify } from 'yaml';
 import { Terminal } from '@travetto/terminal';
 import { TimeUtil, Runtime, RuntimeIndex, hasToJSON } from '@travetto/runtime';
 
-import { TestEvent } from '../../model/event';
-import { SuitesSummary, TestConsumer } from '../types';
-import { Consumable } from '../registry';
+import type { TestEvent } from '../../model/event';
+import type { SuitesSummary, TestConsumerShape } from '../types';
+import { TestConsumer } from '../registry';
 import { SerializeUtil } from '../serialize';
 import { TestResultsEnhancer, CONSOLE_ENHANCER } from '../enhancer';
 
 /**
   * TAP Format consumer
  */
-@Consumable('tap')
-export class TapEmitter implements TestConsumer {
+@TestConsumer()
+export class TapEmitter implements TestConsumerShape {
   #count = 0;
   #enhancer: TestResultsEnhancer;
   #terminal: Terminal;
@@ -27,6 +27,10 @@ export class TapEmitter implements TestConsumer {
     this.#enhancer = enhancer;
   }
 
+  get enhancer(): TestResultsEnhancer {
+    return this.#enhancer;
+  }
+
   log(message: string): void {
     this.#terminal.writer.writeLine(message).commit();
   }
@@ -36,7 +40,7 @@ export class TapEmitter implements TestConsumer {
    */
   onStart(): void {
     this.#start = Date.now();
-    this.log(this.#enhancer.suiteName('TAP version 13')!);
+    this.log(this.#enhancer.suiteName('TAP version 14')!);
   }
 
   /**
@@ -44,7 +48,7 @@ export class TapEmitter implements TestConsumer {
    */
   logMeta(obj: Record<string, unknown>): void {
     const lineLength = this.#terminal.width - 5;
-    let body = stringify(obj, { lineWidth: lineLength });
+    let body = stringify(obj, { lineWidth: lineLength, indent: 2 });
     body = body.split('\n').map(x => `  ${x}`).join('\n');
     this.log(`---\n${this.#enhancer.objectInspect(body)}\n...`);
   }

package/src/consumer/types/xunit.ts

@@ -1,18 +1,18 @@
-import { Writable } from 'node:stream';
+import type { 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';
+import type { TestEvent } from '../../model/event';
+import type { SuitesSummary, TestConsumerShape } from '../types';
+import { TestConsumer } from '../registry';
 
 /**
  * Xunit consumer, compatible with JUnit formatters
  */
-@Consumable('xunit')
-export class XunitEmitter implements TestConsumer {
+@TestConsumer()
+export class XunitEmitter implements TestConsumerShape {
   #tests: string[] = [];
   #suites: string[] = [];
   #stream: Writable;

package/src/consumer/types.ts

@@ -24,9 +24,13 @@ export type TestRunState = {
 };
 
 /**
- * A test result handler
+ * A test consumer shape
  */
-export interface TestConsumer {
+export interface TestConsumerShape {
+  /**
+   * Set options
+   */
+  setOptions?(options?: Record<string, unknown>): Promise<void> | void;
   /**
    * Listen for start of the test run
    */

package/src/execute/runner.ts

@@ -10,6 +10,7 @@ import { TestRun } from '../model/test';
 import { TestExecutor } from './executor';
 import { RunnerUtil } from './util';
 import { RunState } from './types';
+import { TestConsumerRegistry } from '../consumer/registry';
 
 /**
  * Test Runner
@@ -26,7 +27,8 @@ export class Runner {
    * Run all files
    */
   async runFiles(globs?: string[]): Promise<boolean> {
-    const consumer = await RunnableTestConsumer.get(this.#state.consumer ?? this.#state.format);
+    const target = await TestConsumerRegistry.getInstance(this.#state);
+    const consumer = new RunnableTestConsumer(target);
     const tests = await RunnerUtil.getTestDigest(globs, this.#state.tags);
     const testRuns = RunnerUtil.getTestRuns(tests)
       .sort((a, b) => a.runId!.localeCompare(b.runId!));
@@ -58,7 +60,9 @@ export class Runner {
       RuntimeIndex.reinitForModule(entry.module);
     }
 
-    const consumer = (await RunnableTestConsumer.get(this.#state.consumer ?? this.#state.format))
+    const target = await TestConsumerRegistry.getInstance(this.#state);
+
+    const consumer = new RunnableTestConsumer(target)
       .withTransformer(e => {
         // Copy run metadata to event
         e.metadata = run.metadata;

package/src/execute/types.ts

@@ -1,4 +1,3 @@
-import { TestConsumer } from '../consumer/types';
 import { TestRun } from '../model/test';
 
 /**
@@ -6,13 +5,13 @@ import { TestRun } from '../model/test';
  */
 export interface RunState {
   /**
-   * Output format
+   * Test result consumer
    */
-  format: string;
+  consumer: string;
   /**
-   * The run consumer
+   * Test result consumer options?
    */
-  consumer?: TestConsumer;
+  consumerOptions?: Record<string, unknown>;
   /**
    * Number of test suites to run concurrently, when mode is not single
    */

package/src/execute/watcher.ts

@@ -34,7 +34,9 @@ export class TestWatcher {
     }
 
     const itr = new AsyncQueue(events);
-    const consumer = new CumulativeSummaryConsumer(await TestConsumerRegistry.getInstance(format))
+    const consumer = new CumulativeSummaryConsumer(
+      await TestConsumerRegistry.getInstance({ consumer: format })
+    )
       .withFilter(x => x.metadata?.partial !== true || x.type !== 'suite');
 
     new MethodSource(RootRegistry).on(e => {
@@ -42,8 +44,9 @@ export class TestWatcher {
       if (!cls || describeFunction(cls).abstract) {
         return;
       }
+      const classId = cls.Ⲑid;
       if (!method) {
-        consumer.removeClass(cls.Ⲑid);
+        consumer.removeClass(classId);
         return;
       }
       const conf = SuiteRegistry.getByClassAndMethod(cls, method)!;
@@ -60,13 +63,12 @@ export class TestWatcher {
           type: 'removeTest',
           methodNames: method?.name ? [method.name!] : undefined!,
           method: method?.name,
-          classId: cls?.Ⲑid,
+          classId,
           import: Runtime.getImport(cls)
         } satisfies TestRemovedEvent);
       }
     });
 
-
     // If a file is changed, but doesn't emit classes, re-run whole file
     RootRegistry.onNonClassChanges(imp => itr.add({ import: imp }));
 

package/src/worker/child.ts

@@ -81,7 +81,7 @@ export class TestChildWorker extends IpcChannel<TestRun> {
     console.debug('Running', { import: run.import });
 
     try {
-      await new Runner({ format: 'exec', target: run }).run();
+      await new Runner({ consumer: 'exec', target: run }).run();
     } finally {
       this.#done.resolve();
     }

package/support/bin/run.ts

@@ -1,3 +1,8 @@
+import { castTo } from '@travetto/runtime';
+import { AllViewSymbol } from '@travetto/schema/src/internal/types';
+import { SchemaRegistry } from '@travetto/schema';
+
+import { TestConsumerRegistry } from '../../src/consumer/registry';
 import type { RunState } from '../../src/execute/types';
 
 /**
@@ -17,4 +22,22 @@ export async function runTests(opts: RunState): Promise<void> {
     console.error('Test Worker Failed', { error: err });
     process.exitCode = 1;
   }
+}
+
+export async function selectConsumer(inst: { format?: string }) {
+  await TestConsumerRegistry.manualInit();
+
+  let types = TestConsumerRegistry.getTypes();
+
+  if (inst.format?.includes('/')) {
+    await TestConsumerRegistry.importConsumers(inst.format);
+    types = TestConsumerRegistry.getTypes();
+  }
+
+  const cls = inst.constructor;
+
+  SchemaRegistry.get(castTo(cls)).views[AllViewSymbol].schema.format.enum = {
+    message: `{path} is only allowed to be "${types.join('" or "')}"`,
+    values: types
+  };
 }

package/support/cli.test.ts

@@ -7,26 +7,36 @@ import { CliCommandShape, CliCommand, CliValidationError } from '@travetto/cli';
 import { WorkPool } from '@travetto/worker';
 import { Max, Min } from '@travetto/schema';
 
-import { TestFormat, TestMode } from './bin/types';
+import { selectConsumer } from './bin/run';
 
 /**
  * Launch test framework and execute tests
  */
 @CliCommand()
 export class TestCommand implements CliCommandShape {
+
   /** Output format for test results */
-  format: TestFormat = 'tap';
+  format: string = 'tap';
+
   /** Number of tests to run concurrently */
   @Min(1) @Max(WorkPool.MAX_SIZE)
   concurrency: number = WorkPool.DEFAULT_SIZE;
+
   /** Test run mode */
-  mode: TestMode = 'standard';
+  mode: 'single' | 'standard' = 'standard';
+
   /**
    * Tags to target or exclude
    * @alias env.TRV_TEST_TAGS
    */
   tags?: string[];
 
+  /**
+   * Format options
+   * @alias o
+   */
+  formatOptions?: string[];
+
   preMain(): void {
     EventEmitter.defaultMaxListeners = 1000;
     Env.TRV_ROLE.set('test');
@@ -40,12 +50,15 @@ export class TestCommand implements CliCommandShape {
     return fs.stat(path.resolve(first ?? '')).then(x => x.isFile(), () => false);
   }
 
-  async resolvedMode(first: string, rest: string[]): Promise<TestMode> {
+  async resolvedMode(first: string, rest: string[]): Promise<string> {
     return (await this.isFirstFile(first)) && rest.length === 0 ? 'single' : this.mode;
   }
 
-  async validate(first: string = '**/*', rest: string[]): Promise<CliValidationError | undefined> {
+  async preValidate(): Promise<void> {
+    await selectConsumer(this);
+  }
 
+  async validate(first: string = '**/*', rest: string[]): Promise<CliValidationError | undefined> {
     const mode = await this.resolvedMode(first, rest);
 
     if (mode === 'single' && !await this.isFirstFile(first)) {
@@ -58,10 +71,12 @@ export class TestCommand implements CliCommandShape {
 
     const isFirst = await this.isFirstFile(first);
     const isSingle = this.mode === 'single' || (isFirst && globs.length === 0);
+    const options = Object.fromEntries((this.formatOptions ?? [])?.map(f => [...f.split(':'), true]));
 
     return runTests({
       concurrency: this.concurrency,
-      format: this.format,
+      consumer: this.format,
+      consumerOptions: options,
       tags: this.tags,
       target: isSingle ?
         {

package/support/cli.test_direct.ts

@@ -1,14 +1,17 @@
-import { Env, RuntimeIndex } from '@travetto/runtime';
+import { Env } from '@travetto/runtime';
 import { CliCommand } from '@travetto/cli';
 
-import { runTests } from './bin/run';
-import { TestFormat } from './bin/types';
+import { runTests, selectConsumer } from './bin/run';
 
 /**  Direct test invocation */
 @CliCommand({ hidden: true })
 export class TestDirectCommand {
 
-  format: TestFormat = 'tap';
+  format: string = 'tap';
+
+  async preValidate(): Promise<void> {
+    await selectConsumer(this);
+  }
 
   preMain(): void {
     Env.TRV_ROLE.set('test');
@@ -19,7 +22,7 @@ export class TestDirectCommand {
 
   main(importOrFile: string, clsId?: string, methodsNames: string[] = []): Promise<void> {
     return runTests({
-      format: this.format,
+      consumer: this.format,
       target: {
         import: importOrFile,
         classId: clsId,

package/support/cli.test_watch.ts

@@ -1,7 +1,7 @@
 import { Env } from '@travetto/runtime';
 import { CliCommand, CliUtil } from '@travetto/cli';
 
-import { TestFormat } from './bin/types';
+import { selectConsumer } from './bin/run';
 
 /**
  * Invoke the test watcher
@@ -9,9 +9,13 @@ import { TestFormat } from './bin/types';
 @CliCommand()
 export class TestWatcherCommand {
 
-  format: TestFormat = 'tap';
+  format: string = 'tap';
   mode: 'all' | 'change' = 'all';
 
+  async preValidate(): Promise<void> {
+    await selectConsumer(this);
+  }
+
   preMain(): void {
     Env.TRV_ROLE.set('test');
     Env.TRV_DYNAMIC.set(true);

package/support/transformer.assert.ts

@@ -48,21 +48,21 @@ const METHODS: Record<string, Function[]> = {
 
 const OP_TOKEN_TO_NAME = new Map<number, keyof typeof OPTOKEN_ASSERT>();
 
-const AssertⲐ = Symbol.for('@travetto/test:assert');
-const IsTestⲐ = Symbol.for('@travetto/test:valid');
+const AssertSymbol = Symbol.for('@travetto/test:assert');
+const IsTestSymbol = Symbol.for('@travetto/test:valid');
 
 /**
  * Assert transformation state
  */
 interface AssertState {
-  [AssertⲐ]?: {
+  [AssertSymbol]?: {
     assert: ts.Identifier;
     hasAssertCall?: boolean;
     assertCheck: ts.Expression;
     checkThrow: ts.Expression;
     checkThrowAsync: ts.Expression;
   };
-  [IsTestⲐ]?: boolean;
+  [IsTestSymbol]?: boolean;
 }
 
 /**
@@ -136,9 +136,9 @@ export class AssertTransformer {
    * Initialize transformer state
    */
   static initState(state: TransformerState & AssertState): void {
-    if (!state[AssertⲐ]) {
+    if (!state[AssertSymbol]) {
       const asrt = state.importFile('@travetto/test/src/assert/check').ident;
-      state[AssertⲐ] = {
+      state[AssertSymbol] = {
         assert: asrt,
         assertCheck: CoreUtil.createAccess(state.factory, asrt, ASSERT_UTIL, 'check'),
         checkThrow: CoreUtil.createAccess(state.factory, asrt, ASSERT_UTIL, 'checkThrow'),
@@ -157,7 +157,7 @@ export class AssertTransformer {
     const firstText = first!.getText();
 
     cmd.args = cmd.args.filter(x => x !== undefined && x !== null);
-    const check = state.factory.createCallExpression(state[AssertⲐ]!.assertCheck, undefined, state.factory.createNodeArray([
+    const check = state.factory.createCallExpression(state[AssertSymbol]!.assertCheck, undefined, state.factory.createNodeArray([
       state.fromLiteral({
         module: state.getModuleIdentifier(),
         line: state.fromLiteral(ts.getLineAndCharacterOfPosition(state.source, node.getStart()).line + 1),
@@ -180,7 +180,7 @@ export class AssertTransformer {
 
     this.initState(state);
     return state.factory.createCallExpression(
-      /reject/i.test(key) ? state[AssertⲐ]!.checkThrowAsync : state[AssertⲐ]!.checkThrow,
+      /reject/i.test(key) ? state[AssertSymbol]!.checkThrowAsync : state[AssertSymbol]!.checkThrow,
       undefined,
       state.factory.createNodeArray([
         state.fromLiteral({
@@ -269,13 +269,13 @@ export class AssertTransformer {
 
   @OnMethod('AssertCheck')
   static onAssertCheck(state: TransformerState & AssertState, node: ts.MethodDeclaration): ts.MethodDeclaration {
-    state[IsTestⲐ] = true;
+    state[IsTestSymbol] = true;
     return node;
   }
 
   @AfterMethod('AssertCheck')
   static afterAssertCheck(state: TransformerState & AssertState, node: ts.MethodDeclaration): ts.MethodDeclaration {
-    state[IsTestⲐ] = false;
+    state[IsTestSymbol] = false;
     return node;
   }
 
@@ -285,7 +285,7 @@ export class AssertTransformer {
   @OnCall()
   static onAssertCall(state: TransformerState & AssertState, node: ts.CallExpression): ts.CallExpression {
     // Only check in test mode
-    if (!state[IsTestⲐ]) {
+    if (!state[IsTestSymbol]) {
       return node;
     }
 

package/support/bin/types.ts

@@ -1,2 +0,0 @@
-export type TestFormat = 'tap' | 'tap-streamed' | 'xunit' | 'event' | 'exec' | 'json';
-export type TestMode = 'single' | 'standard';