@travetto/test 6.0.2 → 7.0.0-rc.1

package/src/execute/watcher.ts

@@ -1,14 +1,14 @@
-import { RootRegistry, MethodSource } from '@travetto/registry';
+import { Registry } from '@travetto/registry';
 import { WorkPool } from '@travetto/worker';
 import { AsyncQueue, Runtime, RuntimeIndex, castTo, describeFunction } from '@travetto/runtime';
 
-import { SuiteRegistry } from '../registry/suite.ts';
 import { buildStandardTestManager } from '../worker/standard.ts';
-import { TestConsumerRegistry } from '../consumer/registry.ts';
+import { TestConsumerRegistryIndex } from '../consumer/registry-index.ts';
 import { CumulativeSummaryConsumer } from '../consumer/types/cumulative.ts';
 import { TestRun } from '../model/test.ts';
 import { RunnerUtil } from './util.ts';
 import { TestReadyEvent, TestRemovedEvent } from '../worker/types.ts';
+import { SuiteRegistryIndex } from '../registry/registry-index.ts';
 
 /**
  * Test Watcher.
@@ -23,9 +23,7 @@ export class TestWatcher {
   static async watch(format: string, runAllOnStart = true): Promise<void> {
     console.debug('Listening for changes');
 
-    await SuiteRegistry.init();
-    SuiteRegistry.listen(RootRegistry);
-    await RootRegistry.init();
+    await Registry.init();
 
     const events: TestRun[] = [];
 
@@ -36,22 +34,26 @@ export class TestWatcher {
 
     const itr = new AsyncQueue(events);
     const consumer = new CumulativeSummaryConsumer(
-      await TestConsumerRegistry.getInstance({ consumer: format })
+      await TestConsumerRegistryIndex.getInstance({ consumer: format })
     )
       .withFilter(x => x.metadata?.partial !== true || x.type !== 'suite');
 
-    new MethodSource(RootRegistry).on(e => {
-      const [cls, method] = (e.prev ?? e.curr ?? []);
+    Registry.onMethodChange((event) => {
+      const [cls, method] = ('prev' in event && event.prev ? event.prev : null) ??
+        ('curr' in event && event.curr ? event.curr : []);
+
       if (!cls || describeFunction(cls).abstract) {
         return;
       }
+
       const classId = cls.Ⲑid;
       if (!method) {
         consumer.removeClass(classId);
         return;
       }
-      const conf = SuiteRegistry.getByClassAndMethod(cls, method)!;
-      if (e.type !== 'removing') {
+
+      const conf = SuiteRegistryIndex.getTestConfig(cls, method)!;
+      if (event.type !== 'removing') {
         if (conf) {
           const run: TestRun = {
             import: conf.import, classId: conf.classId, methodNames: [conf.methodName], metadata: { partial: true }
@@ -68,10 +70,10 @@ export class TestWatcher {
           import: Runtime.getImport(cls)
         } satisfies TestRemovedEvent);
       }
-    });
+    }, SuiteRegistryIndex);
 
     // If a file is changed, but doesn't emit classes, re-run whole file
-    RootRegistry.onNonClassChanges(imp => itr.add({ import: imp }));
+    Registry.onNonClassChanges(imp => itr.add({ import: imp }));
 
     process.on('message', ev => {
       if (typeof ev === 'object' && ev && 'type' in ev && ev.type === 'run-test') {

package/src/model/common.ts

@@ -9,10 +9,6 @@ export interface SuiteCore {
    * The class id
    */
   classId: string;
-  /**
-   * The tests' description
-   */
-  description: string;
   /**
    * The import location for the suite
    */
@@ -29,6 +25,10 @@ export interface SuiteCore {
    * Tags for a suite or a test
    */
   tags?: string[];
+  /**
+   * Description
+   */
+  description?: string;
 }
 
 /**

package/src/model/suite.ts

@@ -6,11 +6,11 @@ import { Skip, SuiteCore } from './common.ts';
 /**
  * Suite configuration
  */
-export interface SuiteConfig<T = unknown> extends SuiteCore {
+export interface SuiteConfig extends SuiteCore {
   /**
    * Class suite is in
    */
-  class: Class<T>;
+  class: Class;
   /**
    * Should this be skipped
    */
@@ -18,11 +18,11 @@ export interface SuiteConfig<T = unknown> extends SuiteCore {
   /**
    * Actual class instance
    */
-  instance: T;
+  instance?: unknown;
   /**
-   * List of tests to run
+   * Tests to run
    */
-  tests: TestConfig[];
+  tests: Record<string | symbol, TestConfig>;
   /**
    * Before all handlers
    */

package/src/registry/registry-adapter.ts

@@ -0,0 +1,127 @@
+import { RegistryAdapter } from '@travetto/registry';
+import { AppError, asFull, Class, describeFunction, Runtime, safeAssign } from '@travetto/runtime';
+import { SchemaRegistryIndex } from '@travetto/schema';
+
+import { SuiteConfig } from '../model/suite';
+import { TestConfig } from '../model/test';
+
+function combineClasses(baseConfig: SuiteConfig, ...subConfig: Partial<SuiteConfig>[]): SuiteConfig {
+  for (const cfg of subConfig) {
+    if (cfg.beforeAll) {
+      baseConfig.beforeAll = [...baseConfig.beforeAll, ...cfg.beforeAll];
+    }
+    if (cfg.beforeEach) {
+      baseConfig.beforeEach = [...baseConfig.beforeEach, ...cfg.beforeEach];
+    }
+    if (cfg.afterAll) {
+      baseConfig.afterAll = [...baseConfig.afterAll, ...cfg.afterAll];
+    }
+    if (cfg.afterEach) {
+      baseConfig.afterEach = [...baseConfig.afterEach, ...cfg.afterEach];
+    }
+    if (cfg.tags) {
+      baseConfig.tags = [...baseConfig.tags ?? [], ...cfg.tags];
+    }
+    if (cfg.tests) {
+      for (const [key, test] of Object.entries(cfg.tests ?? {})) {
+        baseConfig.tests[key] = {
+          ...test,
+          sourceImport: Runtime.getImport(baseConfig.class),
+          class: baseConfig.class,
+          classId: baseConfig.classId,
+          import: baseConfig.import,
+        };
+      }
+    }
+  }
+  return baseConfig;
+}
+
+function combineMethods(suite: SuiteConfig, baseConfig: TestConfig, ...subConfig: Partial<TestConfig>[]): TestConfig {
+  baseConfig.classId = suite.classId;
+  baseConfig.import = suite.import;
+  for (const cfg of subConfig) {
+    safeAssign(baseConfig, cfg, {
+      tags: [
+        ...baseConfig.tags ?? [],
+        ...cfg.tags ?? []
+      ]
+    });
+  }
+  return baseConfig;
+}
+
+export class SuiteRegistryAdapter implements RegistryAdapter<SuiteConfig> {
+  #cls: Class;
+  #config: SuiteConfig;
+
+  constructor(cls: Class) {
+    this.#cls = cls;
+  }
+
+  register(...data: Partial<SuiteConfig>[]): SuiteConfig {
+    if (!this.#config) {
+      const lines = describeFunction(this.#cls)?.lines;
+      this.#config = asFull<SuiteConfig>({
+        class: this.#cls,
+        classId: this.#cls.Ⲑid,
+        tags: [],
+        import: Runtime.getImport(this.#cls),
+        lineStart: lines?.[0],
+        lineEnd: lines?.[1],
+        tests: {},
+        beforeAll: [],
+        beforeEach: [],
+        afterAll: [],
+        afterEach: []
+      });
+    }
+    combineClasses(this.#config, ...data);
+    return this.#config;
+  }
+
+  registerTest(method: string | symbol, ...data: Partial<TestConfig>[]): TestConfig {
+    const suite = this.register();
+
+    if (!(method in this.#config.tests)) {
+      const lines = describeFunction(this.#cls)?.methods?.[method]?.lines;
+      const config = asFull<TestConfig>({
+        class: this.#cls,
+        tags: [],
+        import: Runtime.getImport(this.#cls),
+        lineStart: lines?.[0],
+        lineEnd: lines?.[1],
+        lineBodyStart: lines?.[2],
+        methodName: method.toString(),
+      });
+      this.#config.tests[method] = config;
+    }
+
+    const result = this.#config.tests[method];
+    combineMethods(suite, result, ...data);
+    return result;
+  }
+
+  finalize(parent?: SuiteConfig): void {
+    if (parent) {
+      combineClasses(this.#config, parent);
+    }
+
+    for (const test of Object.values(this.#config.tests)) {
+      test.tags = [...test.tags ?? [], ...this.#config.tags ?? []];
+      test.description ||= SchemaRegistryIndex.get(this.#cls).getMethod(test.methodName).description;
+    }
+  }
+
+  get(): SuiteConfig {
+    return this.#config;
+  }
+
+  getMethod(method: string | symbol): TestConfig {
+    const test = this.#config.tests[method];
+    if (!test) {
+      throw new AppError(`Test not registered: ${String(method)} on ${this.#cls.name}`);
+    }
+    return test;
+  }
+}

package/src/registry/registry-index.ts

@@ -0,0 +1,117 @@
+import { AppError, Class, Runtime, describeFunction } from '@travetto/runtime';
+import { ChangeEvent, RegistryIndex, RegistryIndexStore, Registry } from '@travetto/registry';
+
+import { SuiteConfig } from '../model/suite.ts';
+import { TestConfig, TestRun } from '../model/test.ts';
+import { SuiteRegistryAdapter } from './registry-adapter.ts';
+
+const sortedTests = (cfg: SuiteConfig): TestConfig[] =>
+  Object.values(cfg.tests).toSorted((a, b) => a.lineStart - b.lineStart);
+
+type SuiteTests = { suite: SuiteConfig, tests: TestConfig[] };
+
+/**
+ * Test Suite registry
+ */
+export class SuiteRegistryIndex implements RegistryIndex {
+
+  static #instance = Registry.registerIndex(this);
+
+  static getForRegister(cls: Class): SuiteRegistryAdapter {
+    return this.#instance.store.getForRegister(cls);
+  }
+
+  static has(cls: Class): boolean {
+    return this.#instance.store.has(cls);
+  }
+
+  static getTestConfig(cls: Class, method: Function): TestConfig | undefined {
+    return this.#instance.getTestConfig(cls, method);
+  }
+
+  static getSuiteTests(run: TestRun): SuiteTests[] {
+    return this.#instance.getSuiteTests(run);
+  }
+
+  static getConfig(cls: Class): SuiteConfig {
+    return this.#instance.store.get(cls).get();
+  }
+
+  static getClasses(): Class[] {
+    return this.#instance.store.getClasses();
+  }
+
+  store = new RegistryIndexStore(SuiteRegistryAdapter);
+
+  process(_events: ChangeEvent<Class>[]): void {
+    // No-op for now
+  }
+
+  /**
+   * Find all valid tests (ignoring abstract)
+   */
+  getValidClasses(): Class[] {
+    return this.store.getClasses().filter(c => !describeFunction(c).abstract);
+  }
+
+  getConfig(cls: Class): SuiteConfig {
+    return this.store.get(cls).get();
+  }
+
+  /**
+   * Get run parameters from provided input
+   */
+  getSuiteTests(run: TestRun): SuiteTests[] {
+    const clsId = run.classId;
+    const imp = run.import;
+    const methodNames = run.methodNames ?? [];
+
+    if (clsId && /^\d+$/.test(clsId)) { // If we only have a line number
+      const line = parseInt(clsId, 10);
+      const suites = this.getValidClasses()
+        .filter(cls => Runtime.getImport(cls) === imp)
+        .map(x => this.getConfig(x)).filter(x => !x.skip);
+      const suite = suites.find(x => line >= x.lineStart && line <= x.lineEnd);
+
+      if (suite) {
+        const tests = sortedTests(suite);
+        const test = tests.find(x => line >= x.lineStart && line <= x.lineEnd);
+        return test ? [{ suite, tests: [test] }] : [{ suite, tests }];
+      } else {
+        return suites.map(x => ({ suite: x, tests: sortedTests(x) }));
+      }
+    } else { // Else lookup directly
+      if (methodNames.length) {
+        const cls = this.getValidClasses().find(x => x.Ⲑid === clsId);
+        if (!cls) {
+          throw new AppError('Unable to find suite for class ID', { details: { classId: clsId } });
+        }
+        const suite = this.getConfig(cls);
+        const tests = sortedTests(suite).filter(x => methodNames.includes(x.methodName));
+        return [{ suite, tests }];
+      } else if (clsId) {
+        const cls = this.getValidClasses().find(x => x.Ⲑid === clsId)!;
+        if (!cls) {
+          throw new AppError('Unable to find suite for class ID', { details: { classId: clsId } });
+        }
+        const suite = this.getConfig(cls);
+        return suite ? [{ suite, tests: sortedTests(suite) }] : [];
+      } else {
+        const suites = this.getValidClasses()
+          .map(x => this.getConfig(x))
+          .filter(x => !describeFunction(x.class).abstract);  // Do not run abstract suites
+        return suites.map(x => ({ suite: x, tests: sortedTests(x) }));
+      }
+    }
+  }
+
+  /**
+   * Find a test configuration given class and optionally a method
+   */
+  getTestConfig(cls: Class, method: Function): TestConfig | undefined {
+    if (this.store.has(cls)) {
+      const conf = this.getConfig(cls);
+      return Object.values(conf.tests).find(x => x.methodName === method.name);
+    }
+  }
+}

package/support/bin/run.ts

@@ -1,7 +1,7 @@
-import { castTo, Runtime } from '@travetto/runtime';
-import { SchemaRegistry } from '@travetto/schema';
+import { getClass, Runtime } from '@travetto/runtime';
+import { SchemaRegistryIndex } from '@travetto/schema';
 
-import { TestConsumerRegistry } from '../../src/consumer/registry.ts';
+import { TestConsumerRegistryIndex } from '../../src/consumer/registry-index.ts';
 import type { RunState } from '../../src/execute/types.ts';
 
 /**
@@ -23,20 +23,17 @@ export async function runTests(opts: RunState): Promise<void> {
   }
 }
 
-export async function selectConsumer(inst: { format?: string }) {
-  await TestConsumerRegistry.manualInit();
-
-  let types = TestConsumerRegistry.getTypes();
-
-  if (inst.format?.includes('/')) {
-    await Runtime.importFrom(inst.format);
-    types = TestConsumerRegistry.getTypes();
+export async function selectConsumer(instance: { format?: string }) {
+  if (instance.format?.includes('/')) {
+    await Runtime.importFrom(instance.format);
   }
 
-  const cls = inst.constructor;
+  const types = await TestConsumerRegistryIndex.getTypes();
 
-  SchemaRegistry.get(castTo(cls)).totalView.schema.format.enum = {
-    message: `{path} is only allowed to be "${types.join('" or "')}"`,
-    values: types
-  };
+  SchemaRegistryIndex.getForRegister(getClass(instance), true).registerField('format', {
+    enum: {
+      message: `{path} is only allowed to be "${types.join('" or "')}"`,
+      values: types
+    }
+  });
 }

package/support/cli.test_child.ts

@@ -2,9 +2,11 @@ import { EventEmitter } from 'node:events';
 
 import { Env } from '@travetto/runtime';
 import { CliCommand } from '@travetto/cli';
+import { IsPrivate } from '@travetto/schema';
 
 /** Test child worker target */
-@CliCommand({ hidden: true })
+@CliCommand()
+@IsPrivate()
 export class TestChildWorkerCommand {
   preMain(): void {
     EventEmitter.defaultMaxListeners = 1000;

package/support/cli.test_digest.ts

@@ -1,10 +1,13 @@
 import { CliCommand } from '@travetto/cli';
 import { Env, Runtime, describeFunction } from '@travetto/runtime';
+import { Registry } from '@travetto/registry';
+import { IsPrivate } from '@travetto/schema';
 
-import { SuiteRegistry } from '../src/registry/suite.ts';
+import { SuiteRegistryIndex } from '../src/registry/registry-index.ts';
 import { RunnerUtil } from '../src/execute/util.ts';
 
-@CliCommand({ hidden: true })
+@CliCommand()
+@IsPrivate()
 export class TestDigestCommand {
 
   output: 'json' | 'text' = 'text';
@@ -24,13 +27,17 @@ export class TestDigestCommand {
       }
     }
 
-    await SuiteRegistry.init();
+    await Registry.init();
 
-    const suites = SuiteRegistry.getClasses();
+    const suites = SuiteRegistryIndex.getClasses();
     const all = suites
-      .map(c => SuiteRegistry.get(c))
+      .map(c => SuiteRegistryIndex.getConfig(c))
       .filter(c => !describeFunction(c.class).abstract)
-      .flatMap(c => c.tests);
+      .flatMap(c => Object.values(c.tests))
+      .toSorted((a, b) => {
+        const classComp = a.classId.localeCompare(b.classId);
+        return classComp !== 0 ? classComp : a.methodName.localeCompare(b.methodName);
+      });
 
     if (this.output === 'json') {
       console.log(JSON.stringify(all));

package/support/cli.test_direct.ts

@@ -1,14 +1,23 @@
 import { Env } from '@travetto/runtime';
 import { CliCommand } from '@travetto/cli';
+import { IsPrivate } from '@travetto/schema';
 
 import { runTests, selectConsumer } from './bin/run.ts';
 
 /**  Direct test invocation */
-@CliCommand({ hidden: true })
+@CliCommand()
+@IsPrivate()
 export class TestDirectCommand {
 
+  @IsPrivate()
   format: string = 'tap';
 
+  /**
+   * Format options
+   * @alias o
+   */
+  formatOptions?: string[];
+
   async preValidate(): Promise<void> {
     await selectConsumer(this);
   }
@@ -21,8 +30,12 @@ export class TestDirectCommand {
   }
 
   main(importOrFile: string, clsId?: string, methodsNames: string[] = []): Promise<void> {
+
+    const options = Object.fromEntries((this.formatOptions ?? [])?.map(f => [...f.split(':'), true]));
+
     return runTests({
       consumer: this.format,
+      consumerOptions: options,
       target: {
         import: importOrFile,
         classId: clsId,

package/src/consumer/registry.ts

@@ -1,68 +0,0 @@
-import path from 'node:path';
-
-import { classConstruct, describeFunction, type Class } from '@travetto/runtime';
-
-import type { TestConsumerShape } from './types.ts';
-import type { RunState } from '../execute/types.ts';
-
-/**
- * Test Results Handler Registry
- */
-class $TestConsumerRegistry {
-  #registered = new Map<string, Class<TestConsumerShape>>();
-
-  /**
-   * Manual initialization when running outside of the bootstrap process
-   */
-  async manualInit(): Promise<void> {
-    await import('./types/all.ts');
-  }
-
-  /**
-   * Add a new consumer
-   * @param cls The consumer class
-   */
-  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<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(state: Pick<RunState, 'consumer' | 'consumerOptions'>): Promise<TestConsumerShape> {
-    // TODO: Fix consumer registry init
-    await this.manualInit();
-    const inst = classConstruct(this.get(state.consumer));
-    await inst.setOptions?.(state.consumerOptions ?? {});
-    return inst;
-  }
-}
-
-export const TestConsumerRegistry = new $TestConsumerRegistry();
-
-/**
- * Registers a class a valid test consumer
- */
-export function TestConsumer(): (cls: Class<TestConsumerShape>) => void {
-  return function (cls: Class<TestConsumerShape>): void {
-    TestConsumerRegistry.add(cls);
-  };
-}

package/src/consumer/types/all.ts

@@ -1,10 +0,0 @@
-import './cumulative';
-import './event';
-import './exec';
-import './json';
-import './noop';
-import './runnable';
-import './summarizer';
-import './tap-summary';
-import './tap';
-import './xunit';