@travetto/test 5.0.0-rc.0 → 5.0.0-rc.10

package/src/registry/suite.ts

@@ -1,9 +1,8 @@
-import { Class, ConcreteClass } from '@travetto/base';
-import { RuntimeIndex, RuntimeContext } from '@travetto/manifest';
+import { Class, Runtime, classConstruct, describeFunction, asFull } from '@travetto/runtime';
 import { MetadataRegistry } from '@travetto/registry';
 
 import { SuiteConfig } from '../model/suite';
-import { TestConfig } from '../model/test';
+import { TestConfig, TestRun } from '../model/test';
 
 /**
  * Test Suite registry
@@ -14,18 +13,18 @@ class $SuiteRegistry extends MetadataRegistry<SuiteConfig, TestConfig> {
    * Find all valid tests (ignoring abstract)
    */
   getValidClasses(): Class[] {
-    return this.getClasses().filter(c => !RuntimeIndex.getFunctionMetadata(c)?.abstract);
+    return this.getClasses().filter(c => !describeFunction(c).abstract);
   }
 
   createPending(cls: Class): Partial<SuiteConfig> {
-    const meta = RuntimeIndex.getFunctionMetadata(cls)!;
+    const lines = describeFunction(cls)?.lines;
     return {
       class: cls,
-      module: RuntimeContext.main.name,
       classId: cls.Ⲑid,
-      file: meta.source,
-      lineStart: meta.lines[0],
-      lineEnd: meta.lines[1],
+      tags: [],
+      import: Runtime.getImport(cls),
+      lineStart: lines?.[0],
+      lineEnd: lines?.[1],
       tests: [],
       beforeAll: [],
       beforeEach: [],
@@ -35,14 +34,14 @@ class $SuiteRegistry extends MetadataRegistry<SuiteConfig, TestConfig> {
   }
 
   override createPendingField(cls: Class, fn: Function): Partial<TestConfig> {
-    const meta = RuntimeIndex.getFunctionMetadata(cls)!;
-    const meth = meta.methods![fn.name];
+    const lines = describeFunction(cls)?.methods?.[fn.name].lines;
     return {
       class: cls,
-      module: RuntimeContext.main.name,
-      file: meta.source,
-      lineStart: meth?.lines[0],
-      lineEnd: meth?.lines[1],
+      tags: [],
+      import: Runtime.getImport(cls),
+      lineStart: lines?.[0],
+      lineEnd: lines?.[1],
+      lineBodyStart: lines?.[2],
       methodName: fn.name
     };
   }
@@ -60,8 +59,7 @@ class $SuiteRegistry extends MetadataRegistry<SuiteConfig, TestConfig> {
    * a full projection of all listeners and tests.
    */
   onInstallFinalize<T>(cls: Class<T>): SuiteConfig {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const config = this.getOrCreatePending(cls) as SuiteConfig;
+    const config = asFull(this.getOrCreatePending(cls));
     const tests = [...this.pendingFields.get(cls.Ⲑid)!.values()];
 
     const parent = this.getParentClass(cls);
@@ -74,20 +72,19 @@ class $SuiteRegistry extends MetadataRegistry<SuiteConfig, TestConfig> {
       config.beforeEach.push(...pConf.beforeEach);
       tests.push(...[...pConf.tests.values()].map(t => ({
         ...t,
+        sourceImport: pConf.import,
         class: cls
       })));
     }
 
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    config.instance = new (config.class as ConcreteClass)();
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    config.tests = tests as TestConfig[];
+    config.instance = classConstruct(config.class);
+    config.tests = tests!.map(x => asFull(x));
+    config.description ||= config.classId;
 
-    if (!config.description) {
-      config.description = config.classId;
-    }
     for (const t of config.tests) {
       t.classId = config.classId;
+      t.import = config.import;
+      t.tags = [...t.tags!, ...config.tags!];
     }
     return config;
   }
@@ -95,33 +92,39 @@ 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 } {
-    if (clsName && /^\d+$/.test(clsName)) { // If we only have a line number
-      const line = parseInt(clsName, 10);
-      const suites = this.getValidClasses().filter(cls => RuntimeIndex.getFunctionMetadata(cls)!.source === file).map(x => this.get(x)).filter(x => !x.skip);
+  getSuiteTests(run: TestRun): { suite: SuiteConfig, tests: TestConfig[] }[] {
+    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.get(x)).filter(x => !x.skip);
       const suite = suites.find(x => line >= x.lineStart && line <= x.lineEnd);
 
       if (suite) {
         const test = suite.tests.find(x => line >= x.lineStart && line <= x.lineEnd);
-        return test ? { suite, test } : { suite };
+        return test ? [{ suite, tests: [test] }] : [{ suite, tests: suite.tests }];
       } else {
-        return { suites };
+        return suites.map(x => ({ suite: x, tests: x.tests }));
       }
     } else { // Else lookup directly
-      if (method) {
-        const cls = this.getValidClasses().find(x => x.name === clsName)!;
+      if (methodNames.length) {
+        const cls = this.getValidClasses().find(x => x.Ⲑid === clsId)!;
         const suite = this.get(cls);
-        const test = suite.tests.find(x => x.methodName === method)!;
-        return { suite, test };
-      } else if (clsName) {
-        const cls = this.getValidClasses().find(x => x.name === clsName)!;
+        const tests = suite.tests.filter(x => methodNames.includes(x.methodName))!;
+        return [{ suite, tests }];
+      } else if (clsId) {
+        const cls = this.getValidClasses().find(x => x.Ⲑid === clsId)!;
         const suite = this.get(cls);
-        return { suite };
+        return [{ suite, tests: suite.tests }];
       } else {
         const suites = this.getValidClasses()
           .map(x => this.get(x))
-          .filter(x => !RuntimeIndex.getFunctionMetadata(x.class)?.abstract);  // Do not run abstract suites
-        return { suites };
+          .filter(x => !describeFunction(x.class).abstract);  // Do not run abstract suites
+        return suites.map(x => ({ suite: x, tests: x.tests }));
       }
     }
   }

package/src/trv.d.ts

@@ -1,4 +1,4 @@
-import { TimeSpan } from '@travetto/base';
+import { TimeSpan } from '@travetto/runtime';
 
 declare global {
   interface TravettoEnv {
@@ -13,8 +13,8 @@ declare global {
      */
     TRV_TEST_TIMEOUT: TimeSpan | number;
     /**
-     * Should the test break on the first line of debugging
+     * The tags to include or exclude during testing
      */
-    TRV_TEST_BREAK_ENTRY: boolean;
+    TRV_TEST_TAGS: string[];
   }
 }

package/src/worker/child.ts

@@ -1,19 +1,19 @@
 import { createWriteStream } from 'node:fs';
 
-import { RuntimeContext } from '@travetto/manifest';
-import { ConsoleManager, Env, Util } from '@travetto/base';
+import { ConsoleManager, Env, Util, Runtime } from '@travetto/runtime';
 import { ChildCommChannel } from '@travetto/worker';
 
-import { ErrorUtil } from '../consumer/error';
+import { SerializeUtil } from '../consumer/serialize';
 import { RunnerUtil } from '../execute/util';
 import { Runner } from '../execute/runner';
-import { Events, RunEvent } from './types';
+import { Events } from './types';
+import { TestRun } from '../model/test';
 
 /**
  * Child Worker for the Test Runner.  Receives events as commands
  * to run specific tests
  */
-export class TestChildWorker extends ChildCommChannel<RunEvent> {
+export class TestChildWorker extends ChildCommChannel<TestRun> {
 
   #done = Util.resolvablePromise();
 
@@ -26,7 +26,7 @@ export class TestChildWorker extends ChildCommChannel<RunEvent> {
         throw err;
       }
       // Mark as errored out
-      this.send(type, { error: ErrorUtil.serializeError(err) });
+      this.send(type, { error: SerializeUtil.serializeError(err) });
     }
   }
 
@@ -35,7 +35,7 @@ export class TestChildWorker extends ChildCommChannel<RunEvent> {
    */
   async activate(): Promise<void> {
     if (/\b@travetto[/]test\b/.test(Env.DEBUG.val ?? '')) {
-      const file = RuntimeContext.toolPath(`test-worker.${process.pid}.log`);
+      const file = Runtime.toolPath(`test-worker.${process.pid}.log`);
       const stdout = createWriteStream(file, { flags: 'a' });
       const c = new console.Console({ stdout, inspectOptions: { depth: 4, colors: false } });
       ConsoleManager.set({ log: (ev) => c[ev.level](process.pid, ...ev.args) });
@@ -57,7 +57,7 @@ export class TestChildWorker extends ChildCommChannel<RunEvent> {
   /**
    * When we receive a command from the parent
    */
-  async onCommand(event: RunEvent & { type: string }): Promise<boolean> {
+  async onCommand(event: TestRun & { type: string }): Promise<boolean> {
     console.debug('on message', { ...event });
 
     if (event.type === Events.INIT) { // On request to init, start initialization
@@ -77,18 +77,11 @@ export class TestChildWorker extends ChildCommChannel<RunEvent> {
   /**
    * Run a specific test/suite
    */
-  async onRunCommand(event: RunEvent): Promise<void> {
-    console.debug('Run');
-
-    console.debug('Running', { file: event.file });
+  async onRunCommand(run: TestRun): Promise<void> {
+    console.debug('Running', { import: run.import });
 
     try {
-      await new Runner({
-        format: 'exec',
-        mode: 'single',
-        args: [event.file!, event.class!, event.method!],
-        concurrency: 1
-      }).run();
+      await new Runner({ format: 'exec', target: run }).run();
     } finally {
       this.#done.resolve();
     }

package/src/worker/standard.ts

@@ -1,39 +1,36 @@
 import { fork } from 'node:child_process';
 
-import { RuntimeIndex } from '@travetto/manifest';
-import { Env } from '@travetto/base';
+import { Env, RuntimeIndex } from '@travetto/runtime';
 import { ParentCommChannel } from '@travetto/worker';
 
-import { Events, RunEvent } from './types';
+import { Events, TestLogEvent } from './types';
 import { TestConsumer } from '../consumer/types';
-import { ErrorUtil } from '../consumer/error';
+import { SerializeUtil } from '../consumer/serialize';
 import { TestEvent } from '../model/event';
+import { TestRun } from '../model/test';
+
+const log = (message: string): void => {
+  process.send?.({ type: 'log', message } satisfies TestLogEvent);
+};
 
 /**
  *  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}` });
-
-  let event: RunEvent;
-  if (file.includes('#')) {
-    const [f, cls, method] = file.split('#');
-    event = { file: f, class: cls, method };
-  } else {
-    event = { file };
-  }
+export async function buildStandardTestManager(consumer: TestConsumer, run: TestRun): Promise<void> {
+  log(`Worker Input ${JSON.stringify(run)}`);
+  log(`Worker Executing ${run.import}`);
 
-  const { module } = RuntimeIndex.getEntry(event.file!)!;
-  const cwd = RuntimeIndex.getModule(module)!.sourcePath;
+  const { module } = RuntimeIndex.getFromImport(run.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']
@@ -56,7 +53,7 @@ export async function buildStandardTestManager(consumer: TestConsumer, file: str
   // Listen for child to complete
   const complete = channel.once(Events.RUN_COMPLETE);
   // Start test
-  channel.send(Events.RUN, event);
+  channel.send(Events.RUN, run);
 
   // Wait for complete
   const { error } = await complete;
@@ -64,10 +61,10 @@ export async function buildStandardTestManager(consumer: TestConsumer, file: str
   // Kill on complete
   await channel.destroy();
 
-  process.send?.({ type: 'log', message: `Worker Finished ${file}` });
+  log(`Worker Finished ${run.import}`);
 
   // If we received an error, throw it
   if (error) {
-    throw ErrorUtil.deserializeError(error);
+    throw SerializeUtil.deserializeError(error);
   }
 }

package/src/worker/types.ts

@@ -1,12 +1,5 @@
-/**
- * Test Run Event
- */
-export type RunEvent = {
-  file?: string;
-  error?: unknown;
-  class?: string;
-  method?: string;
-};
+import { TestEvent } from '../model/event';
+import { TestRun } from '../model/test';
 
 /**
  * Test Run Event Keys
@@ -17,4 +10,14 @@ export const Events = {
   INIT: 'init',
   INIT_COMPLETE: 'initComplete',
   READY: 'ready'
-};
+};
+
+export type TestRemovedEvent = { type: 'removeTest', method?: string } & TestRun;
+export type TestReadyEvent = { type: 'ready' };
+export type TestLogEvent = { type: 'log', message: string };
+
+export type TestWatchEvent =
+  TestEvent |
+  TestRemovedEvent |
+  TestReadyEvent |
+  TestLogEvent;

package/support/cli.test.ts

@@ -2,7 +2,7 @@ import { EventEmitter } from 'node:events';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 
-import { Env } from '@travetto/base';
+import { Env } from '@travetto/runtime';
 import { CliCommandShape, CliCommand, CliValidationError } from '@travetto/cli';
 import { WorkPool } from '@travetto/worker';
 import { Max, Min } from '@travetto/schema';
@@ -21,6 +21,11 @@ export class TestCommand implements CliCommandShape {
   concurrency: number = WorkPool.DEFAULT_SIZE;
   /** Test run mode */
   mode: TestMode = 'standard';
+  /**
+   * Tags to target or exclude
+   * @alias env.TRV_TEST_TAGS
+   */
+  tags?: string[];
 
   preMain(): void {
     EventEmitter.defaultMaxListeners = 1000;
@@ -39,7 +44,7 @@ export class TestCommand implements CliCommandShape {
     return (await this.isFirstFile(first)) && rest.length === 0 ? 'single' : this.mode;
   }
 
-  async validate(first: string = 'test/.*', rest: string[]): Promise<CliValidationError | undefined> {
+  async validate(first: string = '**/*', rest: string[]): Promise<CliValidationError | undefined> {
 
     const mode = await this.resolvedMode(first, rest);
 
@@ -48,14 +53,23 @@ export class TestCommand implements CliCommandShape {
     }
   }
 
-  async main(first: string = 'test/.*', regexes: string[] = []): Promise<void> {
+  async main(first: string = '**/*', globs: string[] = []): Promise<void> {
     const { runTests } = await import('./bin/run');
 
+    const isFirst = await this.isFirstFile(first);
+    const isSingle = this.mode === 'single' || (isFirst && globs.length === 0);
+
     return runTests({
-      args: [first, ...regexes],
-      mode: await this.resolvedMode(first, regexes),
       concurrency: this.concurrency,
-      format: this.format
+      format: this.format,
+      tags: this.tags,
+      target: isSingle ?
+        {
+          import: first,
+          classId: globs[0],
+          methodNames: globs.slice(1),
+        } :
+        { globs: [first, ...globs], }
     });
   }
 }

package/support/cli.test_child.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'node:events';
 
-import { Env } from '@travetto/base';
+import { Env } from '@travetto/runtime';
 import { CliCommand } from '@travetto/cli';
 
 /** Test child worker target */

package/support/cli.test_digest.ts

@@ -0,0 +1,43 @@
+import { CliCommand } from '@travetto/cli';
+import { Env, Runtime, describeFunction } from '@travetto/runtime';
+
+import { SuiteRegistry } from '../src/registry/suite';
+import { RunnerUtil } from '../src/execute/util';
+
+@CliCommand({ hidden: true })
+export class TestDigestCommand {
+
+  output: 'json' | 'text' = 'text';
+
+  preMain(): void {
+    Env.TRV_ROLE.set('test');
+    Env.DEBUG.set(false);
+  }
+
+  async main(globs: string[] = ['**/*.ts']) {
+    // Load all tests
+    for await (const imp of await RunnerUtil.getTestImports(globs)) {
+      try {
+        await Runtime.importFrom(imp);
+      } catch (err) {
+        console.error('Failed to import', imp, err);
+      }
+    }
+
+    await SuiteRegistry.init();
+
+    const suites = SuiteRegistry.getClasses();
+    const all = suites
+      .map(c => SuiteRegistry.get(c))
+      .filter(c => !describeFunction(c.class).abstract)
+      .flatMap(c => c.tests);
+
+    if (this.output === 'json') {
+      console.log(JSON.stringify(all));
+    } else {
+      for (const item of all) {
+        console.log(`${item.classId}#${item.methodName}`, item.tags?.join('|') ?? '');
+      }
+    }
+  }
+}

package/support/cli.test_direct.ts

@@ -1,4 +1,4 @@
-import { Env } from '@travetto/base';
+import { Env, RuntimeIndex } from '@travetto/runtime';
 import { CliCommand } from '@travetto/cli';
 
 import { runTests } from './bin/run';
@@ -17,7 +17,14 @@ export class TestDirectCommand {
     Env.TRV_LOG_TIME.clear();
   }
 
-  main(file: string, args: string[]): Promise<void> {
-    return runTests({ args: [file, ...args], format: this.format, mode: 'single', concurrency: 1 });
+  main(importOrFile: string, clsId?: string, methodsNames: string[] = []): Promise<void> {
+    return runTests({
+      format: this.format,
+      target: {
+        import: importOrFile,
+        classId: clsId,
+        methodNames: methodsNames,
+      }
+    });
   }
 }

package/support/cli.test_watch.ts

@@ -1,4 +1,4 @@
-import { Env } from '@travetto/base';
+import { Env } from '@travetto/runtime';
 import { CliCommand, CliUtil } from '@travetto/cli';
 
 import { TestFormat } from './bin/types';

package/support/transformer.assert.ts

@@ -93,7 +93,7 @@ export class AssertTransformer {
   /**
    * Resolves optoken to syntax kind.  Relies on `ts`
    */
-  static lookupOpToken(key: number): string {
+  static lookupOpToken(key: number): string | undefined {
     if (OP_TOKEN_TO_NAME.size === 0) {
       Object.keys(ts.SyntaxKind)
         .filter(x => !/^\d+$/.test(x))
@@ -106,7 +106,7 @@ export class AssertTransformer {
     if (name in OPTOKEN_ASSERT) {
       return OPTOKEN_ASSERT[name];
     } else {
-      throw new Error(`Unknown optoken: ${name}:${key}`);
+      return;
     }
   }
 
@@ -137,12 +137,12 @@ export class AssertTransformer {
    */
   static initState(state: TransformerState & AssertState): void {
     if (!state[AssertⲐ]) {
-      const assrt = state.importFile('@travetto/test/src/assert/check').ident;
+      const asrt = state.importFile('@travetto/test/src/assert/check').ident;
       state[AssertⲐ] = {
-        assert: assrt,
-        assertCheck: CoreUtil.createAccess(state.factory, assrt, ASSERT_UTIL, 'check'),
-        checkThrow: CoreUtil.createAccess(state.factory, assrt, ASSERT_UTIL, 'checkThrow'),
-        checkThrowAsync: CoreUtil.createAccess(state.factory, assrt, ASSERT_UTIL, 'checkThrowAsync'),
+        assert: asrt,
+        assertCheck: CoreUtil.createAccess(state.factory, asrt, ASSERT_UTIL, 'check'),
+        checkThrow: CoreUtil.createAccess(state.factory, asrt, ASSERT_UTIL, 'checkThrow'),
+        checkThrowAsync: CoreUtil.createAccess(state.factory, asrt, ASSERT_UTIL, 'checkThrowAsync'),
       };
     }
   }
@@ -153,13 +153,13 @@ export class AssertTransformer {
   static doAssert(state: TransformerState & AssertState, node: ts.CallExpression, cmd: Command): ts.CallExpression {
     this.initState(state);
 
-    const first = CoreUtil.getArgument<ts.CallExpression>(node);
+    const first = CoreUtil.firstArgument(node);
     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([
       state.fromLiteral({
-        file: state.getFilenameIdentifier(),
+        module: state.getModuleIdentifier(),
         line: state.fromLiteral(ts.getLineAndCharacterOfPosition(state.source, node.getStart()).line + 1),
         text: state.fromLiteral(firstText),
         operator: state.fromLiteral(cmd.fn)
@@ -175,8 +175,8 @@ export class AssertTransformer {
    * Convert `assert.(throws|rejects|doesNotThrow|doesNotReject)` to the appropriate structure
    */
   static doThrows(state: TransformerState & AssertState, node: ts.CallExpression, key: string, args: ts.Expression[]): ts.CallExpression {
-    const first = CoreUtil.getArgument<ts.CallExpression>(node);
-    const firstText = first!.getText();
+    const first = CoreUtil.firstArgument(node)!;
+    const firstText = first.getText();
 
     this.initState(state);
     return state.factory.createCallExpression(
@@ -184,7 +184,7 @@ export class AssertTransformer {
       undefined,
       state.factory.createNodeArray([
         state.fromLiteral({
-          file: state.getFilenameIdentifier(),
+          module: state.getModuleIdentifier(),
           line: state.fromLiteral(ts.getLineAndCharacterOfPosition(state.source, node.getStart()).line + 1),
           text: state.fromLiteral(`${key} ${firstText}`),
           operator: state.fromLiteral(`${key}`)

package/support/cli.test_count.ts

@@ -1,39 +0,0 @@
-import { CliCommand } from '@travetto/cli';
-import { RuntimeIndex } from '@travetto/manifest';
-import { Env } from '@travetto/base';
-
-import { SuiteRegistry } from '../src/registry/suite';
-import { RunnerUtil } from '../src/execute/util';
-
-@CliCommand({ hidden: true })
-export class TestCountCommand {
-
-  preMain(): void {
-    Env.TRV_ROLE.set('test');
-    Env.DEBUG.set(false);
-  }
-
-  async main(patterns: string[]) {
-    const regexes = patterns.map(x => new RegExp(x));
-    const files = await RunnerUtil.getTestFiles(regexes);
-
-    // Load all tests
-    for (const file of files) {
-      try {
-        await import(file.import);
-      } catch (err) {
-        console.error('Failed to import', file.sourceFile, err);
-      }
-    }
-
-    await SuiteRegistry.init();
-
-    const suites = SuiteRegistry.getClasses();
-    const total = suites
-      .map(c => SuiteRegistry.get(c))
-      .filter(c => !RuntimeIndex.getFunctionMetadata(c.class)?.abstract)
-      .reduce((acc, c) => acc + (c.tests?.length ?? 0), 0);
-
-    console.log(total);
-  }
-}