@travetto/test 3.0.0-rc.4 → 3.0.0-rc.6

package/src/registry/suite.ts

@@ -1,4 +1,5 @@
 import { Class, ConcreteClass } from '@travetto/base';
+import { RootIndex } from '@travetto/manifest';
 import { MetadataRegistry } from '@travetto/registry';
 
 import { SuiteConfig } from '../model/suite';
@@ -13,14 +14,15 @@ class $SuiteRegistry extends MetadataRegistry<SuiteConfig, TestConfig> {
    * Find all valid tests (ignoring abstract)
    */
   getValidClasses(): Class[] {
-    return this.getClasses().filter(c => !c.ᚕabstract);
+    return this.getClasses().filter(c => !RootIndex.getFunctionMetadata(c)?.abstract);
   }
 
   createPending(cls: Class): Partial<SuiteConfig> {
     return {
       class: cls,
-      classId: cls.ᚕid,
-      file: cls.ᚕfile,
+      module: RootIndex.manifest.mainModule,
+      classId: cls.Ⲑid,
+      file: RootIndex.getFunctionMetadata(cls)!.source,
       tests: [],
       beforeAll: [],
       beforeEach: [],
@@ -32,7 +34,8 @@ class $SuiteRegistry extends MetadataRegistry<SuiteConfig, TestConfig> {
   override createPendingField(cls: Class, fn: Function): Partial<TestConfig> {
     return {
       class: cls,
-      file: cls.ᚕfile,
+      module: RootIndex.manifest.mainModule,
+      file: RootIndex.getFunctionMetadata(cls)!.source,
       methodName: fn.name
     };
   }
@@ -52,7 +55,7 @@ class $SuiteRegistry extends MetadataRegistry<SuiteConfig, TestConfig> {
   onInstallFinalize<T>(cls: Class<T>): SuiteConfig {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const config = this.getOrCreatePending(cls) as SuiteConfig;
-    const tests = [...this.pendingFields.get(cls.ᚕid)!.values()];
+    const tests = [...this.pendingFields.get(cls.Ⲑid)!.values()];
 
     const parent = this.getParentClass(cls);
 
@@ -88,7 +91,7 @@ class $SuiteRegistry extends MetadataRegistry<SuiteConfig, TestConfig> {
   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(f => f.ᚕfile === file).map(x => this.get(x)).filter(x => !x.skip);
+      const suites = this.getValidClasses().filter(cls => RootIndex.getFunctionMetadata(cls)!.source === file).map(x => this.get(x)).filter(x => !x.skip);
       const suite = suites.find(x => x.lines && (line >= x.lines.start && line <= x.lines.end));
 
       if (suite) {
@@ -110,7 +113,7 @@ class $SuiteRegistry extends MetadataRegistry<SuiteConfig, TestConfig> {
       } else {
         const suites = this.getValidClasses()
           .map(x => this.get(x))
-          .filter(x => !x.class.ᚕabstract);  // Do not run abstract suites
+          .filter(x => !RootIndex.getFunctionMetadata(x.class)?.abstract);  // Do not run abstract suites
         return { suites };
       }
     }

package/src/worker/child.ts

@@ -1,29 +1,16 @@
-import { ModuleManager } from '@travetto/boot/src/internal/module';
-import { SourceIndex } from '@travetto/boot/src/internal/source';
-import { ErrorUtil } from '@travetto/base/src/internal/error';
-import { PhaseManager, ShutdownManager } from '@travetto/base';
+import { ErrorUtil, TimeUtil } from '@travetto/base';
 import { ChildCommChannel } from '@travetto/worker';
 
+import { RunnerUtil } from '../execute/util';
+import { Runner } from '../execute/runner';
 import { Events, RunEvent } from './types';
 
-const FIXED_MODULES = new Set([
-  //  'cache', 'openapi',
-  // 'registry'
-  'boot', 'base', 'cli',
-  'compiler', 'transformer',
-  'yaml', 'worker', 'command',
-  'log', 'jwt', 'image',
-  'test',
-].map(x => `@travetto/${x}`));
-
 /**
  * Child Worker for the Test Runner.  Receives events as commands
  * to run specific tests
  */
 export class TestChildWorker extends ChildCommChannel<RunEvent> {
 
-  #runs = 0;
-
   async #exec(op: () => Promise<unknown>, type: string): Promise<void> {
     try {
       await op();
@@ -41,7 +28,6 @@ export class TestChildWorker extends ChildCommChannel<RunEvent> {
    * Start the worker
    */
   async activate(): Promise<void> {
-    const { RunnerUtil } = await import('../execute/util');
     RunnerUtil.registerCleanup('worker');
 
     // Listen for inbound requests
@@ -49,6 +35,8 @@ export class TestChildWorker extends ChildCommChannel<RunEvent> {
 
     // Let parent know the child is ready for handling commands
     this.send(Events.READY);
+
+    await TimeUtil.wait('10m');
   }
 
   /**
@@ -60,6 +48,7 @@ export class TestChildWorker extends ChildCommChannel<RunEvent> {
     if (event.type === Events.INIT) { // On request to init, start initialization
       await this.#exec(() => this.onInitCommand(), Events.INIT_COMPLETE);
     } else if (event.type === Events.RUN) { // On request to run, start running
+      console.log!(process.stdout.isTTY && process.stdout.getColorDepth());
       await this.#exec(() => this.onRunCommand(event), Events.RUN_COMPLETE);
     }
 
@@ -71,46 +60,12 @@ export class TestChildWorker extends ChildCommChannel<RunEvent> {
    */
   async onInitCommand(): Promise<void> { }
 
-  /**
-   * Reset the state to prepare for the next run
-   */
-  async resetForRun(): Promise<void> {
-    // Clear require cache of all data loaded minus base framework pieces
-    console.debug('Resetting', { fileCount: Object.keys(require.cache).length });
-
-    // Reload registries, test and root
-    await PhaseManager.run('reset');
-    await ShutdownManager.executeAsync(-1);
-
-    for (const { file } of SourceIndex.find({
-      paths: SourceIndex.getPaths().filter(x => !FIXED_MODULES.has(x)),
-      includeIndex: true
-    })) {
-      if (!/support\/(transformer|phase)[.]/.test(file)) {
-        const worked = ModuleManager.unload(file);
-        if (worked) {
-          console.debug('Unloading', { pid: process.pid, file });
-        }
-      }
-    }
-  }
-
   /**
    * Run a specific test/suite
    */
   async onRunCommand(event: RunEvent): Promise<void> {
-    this.#runs += 1;
     console.debug('Run');
 
-    if (this.#runs > 1) {
-      await this.resetForRun();
-    }
-
-    // Run all remaining initializations as needed for tests
-    await PhaseManager.run('init', '*', ['@trv:registry/init']);
-
-    const { Runner } = await import('../execute/runner');
-
     console.debug('Running', { file: event.file });
 
     await new Runner({

package/src/worker/standard.ts

@@ -1,11 +1,22 @@
-import { ErrorUtil } from '@travetto/base/src/internal/error';
-import { ParentCommChannel, Worker, WorkUtil } from '@travetto/worker';
-import { AppCache, ExecUtil } from '@travetto/boot';
+import { RootIndex } from '@travetto/manifest';
+import { ExecUtil, ErrorUtil } from '@travetto/base';
+import { ParentCommChannel, Worker } from '@travetto/worker';
 
 import { Events, RunEvent } from './types';
 import { TestConsumer } from '../consumer/types';
 import { TestEvent } from '../model/event';
 
+let i = 0;
+
+function buildEvent(ev: string): RunEvent {
+  if (ev.includes('#')) {
+    const [file, cls, method] = ev.split('#');
+    return { file, class: cls, method };
+  } else {
+    return { file: ev };
+  }
+}
+
 /**
  *  Produce a handler for the child worker
  */
@@ -13,17 +24,28 @@ export function buildStandardTestManager(consumer: TestConsumer): () => Worker<s
   /**
    * Spawn a child
    */
-  return () => WorkUtil.spawnedWorker(
-    () => ExecUtil.forkMain('@travetto/test/bin/test-child', [], {
-      env: { TRV_CACHE: AppCache.cacheDir }
-    }),
-    /**
-     * Child initialization
-     */
-    async (channel: ParentCommChannel<TestEvent>): Promise<void> => {
+  return () => ({
+    id: i += 1,
+    active: true,
+    async destroy(): Promise<void> { },
+    async execute(file: string): Promise<void> {
+      const event = buildEvent(file);
+
+      const { module } = RootIndex.getEntry(event.file!)!;
+      const cwd = RootIndex.getModule(module)!.source;
+
+      const channel = new ParentCommChannel<TestEvent & { error?: Error }>(
+        ExecUtil.fork(RootIndex.resolveFileImport('@travetto/test/support/main.test-child.ts'), [], {
+          cwd,
+          env: { TRV_MANIFEST: module },
+          stdio: [0, 'ignore', 2, 'ipc']
+        })
+      );
+
       await channel.once(Events.READY); // Wait for the child to be ready
       await channel.send(Events.INIT); // Initialize
       await channel.once(Events.INIT_COMPLETE); // Wait for complete
+
       channel.on('*', async ev => {
         try {
           await consumer.onEvent(ev);  // Connect the consumer with the event stream from the child
@@ -31,23 +53,22 @@ export function buildStandardTestManager(consumer: TestConsumer): () => Worker<s
           // Do nothing
         }
       });
-    },
-    /**
-     * Send child command to run tests
-     */
-    async (channel: ParentCommChannel<TestEvent & { error?: Error }>, event: string | RunEvent): Promise<void> => {
+
       // Listen for child to complete
       const complete = channel.once(Events.RUN_COMPLETE);
       // Start test
-      event = typeof event === 'string' ? { file: event } : event;
       channel.send(Events.RUN, event);
 
       // Wait for complete
       const { error } = await complete;
 
+      // Kill on complete
+      await channel.destroy();
+
       // If we received an error, throw it
       if (error) {
         throw ErrorUtil.deserializeError(error);
       }
-    });
+    },
+  });
 }

package/src/worker/types.ts

@@ -6,7 +6,6 @@ export type RunEvent = {
   error?: unknown;
   class?: string;
   method?: string;
-  mode?: 'extension' | 'standard';
 };
 
 /**

package/{bin/lib → support/bin}/run.ts

@@ -1,3 +1,8 @@
+import { ShutdownManager, TimeUtil } from '@travetto/base';
+
+import { RunnerUtil } from '../../src/execute/util';
+import { Runner } from '../../src/execute/runner';
+
 import type { RunState } from '../../src/execute/types';
 
 declare global {
@@ -14,23 +19,17 @@ declare global {
  * @param opts
  */
 export async function runTests(opts: RunState): Promise<void> {
-  const { PhaseManager, Util } = await import('@travetto/base');
-  await PhaseManager.run('init', '*', ['@trv:registry/init']); // Delay registry
-
-  const { RunnerUtil } = await import('../../src/execute/util');
-  const { Runner } = await import('../../src/execute/runner');
-
   RunnerUtil.registerCleanup('runner');
 
   if (process.env.TRV_TEST_DELAY) {
-    await Util.wait(process.env.TRV_TEST_DELAY);
+    await TimeUtil.wait(process.env.TRV_TEST_DELAY);
   }
 
   try {
     const res = await new Runner(opts).run();
-    process.exit(res ? 0 : 1);
+    return ShutdownManager.exit(res ? 0 : 1);
   } catch (err) {
     console.error('Test Worker Failed', { error: err });
-    process.exit(1);
+    return ShutdownManager.exit(1);
   }
 }

package/support/cli.test.ts

@@ -0,0 +1,76 @@
+import { readFileSync } from 'fs';
+import fs from 'fs/promises';
+
+import { path, RootIndex } from '@travetto/manifest';
+import { GlobalEnvConfig } from '@travetto/base';
+import { CliCommand, OptionConfig } from '@travetto/cli';
+import { WorkPool } from '@travetto/worker';
+
+import type { RunState } from '../src/execute/types';
+
+const modes = ['single', 'standard'] as const;
+
+type Options = {
+  format: OptionConfig<string>;
+  concurrency: OptionConfig<number>;
+  mode: OptionConfig<(typeof modes)[number]>;
+};
+
+/**
+ * Launch test framework and execute tests
+ */
+export class TestCommand extends CliCommand<Options> {
+  name = 'test';
+  _types: string[];
+
+  getTypes(): string[] {
+    if (!this._types) {
+      this._types = RootIndex
+        .findSrc({ filter: /consumer\/types\/.*/, profiles: ['test'] })
+        .map(x => readFileSync(`${x.output}`, 'utf8').match(/Consumable.?[(]'([^']+)/)?.[1])
+        .filter((x?: string): x is string => !!x);
+    }
+    return this._types;
+  }
+
+  getOptions(): Options {
+    return {
+      format: this.choiceOption({ desc: 'Output format for test results', def: 'tap', choices: this.getTypes() }),
+      concurrency: this.intOption({ desc: 'Number of tests to run concurrently', lower: 1, upper: 32, def: WorkPool.DEFAULT_SIZE }),
+      mode: this.choiceOption({ desc: 'Test run mode', def: 'standard', choices: [...modes] })
+    };
+  }
+
+  envInit(): GlobalEnvConfig {
+    return { test: true };
+  }
+
+  getArgs(): string {
+    return '[regexes...]';
+  }
+
+  async action(regexes: string[]): Promise<void> {
+    const { runTests } = await import('./bin/run.js');
+
+    const [first] = regexes;
+
+    const isFile = await fs.stat(path.resolve(first ?? '')).then(x => x.isFile(), () => false);
+
+    const state: RunState = {
+      args: !first ? ['test/.*'] : regexes,
+      mode: isFile && regexes.length === 1 ? 'single' : this.cmd.mode,
+      concurrency: this.cmd.concurrency,
+      format: this.cmd.format
+    };
+
+    if (state.mode === 'single') {
+      if (!isFile) {
+        return this.showHelp('You must specify a proper test file to run in single mode');
+      } else if (!/test\//.test(first)) {
+        return this.showHelp('Only files in the test/ folder are permitted to be run');
+      }
+    }
+
+    await runTests(state);
+  }
+}

package/support/main.test-child.ts

@@ -0,0 +1,32 @@
+import fs from 'fs/promises';
+
+import { ConsoleManager, defineGlobalEnv } from '@travetto/base';
+import { path } from '@travetto/manifest';
+
+import { TestChildWorker } from '../src/worker/child';
+
+export async function customLogs(): Promise<void> {
+  if (/\b@travetto[/]test\b/.test(process.env.DEBUG ?? '')) {
+    const handle = await fs.open(path.resolve(`.trv-test-worker.${process.pid}.log`), 'a');
+    const stdout = handle.createWriteStream();
+
+    const c = new console.Console({
+      stdout,
+      inspectOptions: { depth: 4 },
+    });
+
+    ConsoleManager.set({
+      onLog: (ev) => c[ev.level](process.pid, ...ev.args)
+    });
+  } else {
+    ConsoleManager.set({ onLog: () => { } });
+  }
+}
+
+export async function main(): Promise<void> {
+  defineGlobalEnv({ test: true });
+  ConsoleManager.setDebugFromEnv();
+
+  await customLogs();
+  return new TestChildWorker().activate();
+}

package/support/main.test-direct.ts

@@ -0,0 +1,15 @@
+import { ConsoleManager, defineGlobalEnv } from '@travetto/base';
+import { runTests } from './bin/run';
+
+// Direct entry point
+export function main(...args: string[]): Promise<void> {
+  defineGlobalEnv({ test: true });
+  ConsoleManager.setDebugFromEnv();
+
+  return runTests({
+    args,
+    format: process.env.TRV_TEST_FORMAT ?? 'tap',
+    mode: 'single',
+    concurrency: 1
+  });
+}

package/support/main.test-watch.ts

@@ -0,0 +1,8 @@
+import { ConsoleManager, defineGlobalEnv } from '@travetto/base';
+import { TestWatcher } from '../src/execute/watcher';
+
+export async function main(format: string = 'tap', runAllOnStart: string = 'true'): Promise<void> {
+  defineGlobalEnv({ test: true, dynamic: true });
+  ConsoleManager.setDebugFromEnv();
+  await TestWatcher.watch(format, runAllOnStart !== 'false');
+}

package/support/transformer.annotate.ts

@@ -1,7 +1,7 @@
-import * as ts from 'typescript';
+import ts from 'typescript';
 
 import {
-  TransformerState, DecoratorMeta, OnMethod, OnClass, CoreUtil, DecoratorUtil, TransformerId
+  TransformerState, DecoratorMeta, OnMethod, OnClass, CoreUtil, DecoratorUtil
 } from '@travetto/transformer';
 
 /**
@@ -9,8 +9,6 @@ import {
  */
 export class AnnotationTransformer {
 
-  static [TransformerId] = '@trv:test';
-
   /**
    * Build source annotation, indicating line ranges
    * @param state
@@ -29,8 +27,9 @@ export class AnnotationTransformer {
         [
           ...(expression.arguments ?? []),
           state.fromLiteral({
+            ident: `@${DecoratorUtil.getDecoratorIdent(dec).text}()`,
             lines: {
-              ...CoreUtil.getRangeOf(state.source, n),
+              ...CoreUtil.getRangeOf(state.source, node),
               codeStart: CoreUtil.getRangeOf(state.source, n?.body?.statements[0])?.start
             }
           })

package/support/transformer.assert.ts

@@ -1,7 +1,6 @@
-import * as ts from 'typescript';
+import ts from 'typescript';
 
-import { PathUtil } from '@travetto/boot';
-import { TransformerState, OnCall, DeclarationUtil, CoreUtil, TransformerId } from '@travetto/transformer';
+import { TransformerState, OnCall, DeclarationUtil, CoreUtil, OnMethod, AfterMethod } from '@travetto/transformer';
 
 /**
  * Which types are candidates for deep literal checking
@@ -49,8 +48,8 @@ const METHODS: Record<string, Function[]> = {
 
 const OP_TOKEN_TO_NAME = new Map<number, keyof typeof OPTOKEN_ASSERT>();
 
-const AssertⲐ = Symbol.for('@trv:test/assert');
-const IsTestⲐ = Symbol.for('@trv:test/valid');
+const AssertⲐ = Symbol.for('@travetto/test:assert');
+const IsTestⲐ = Symbol.for('@travetto/test:valid');
 
 /**
  * Assert transformation state
@@ -59,9 +58,9 @@ interface AssertState {
   [AssertⲐ]?: {
     assert: ts.Identifier;
     hasAssertCall?: boolean;
-    assertCheck: ts.PropertyAccessExpression;
-    checkThrow: ts.PropertyAccessExpression;
-    checkThrowAsync: ts.PropertyAccessExpression;
+    assertCheck: ts.Expression;
+    checkThrow: ts.Expression;
+    checkThrowAsync: ts.Expression;
   };
   [IsTestⲐ]?: boolean;
 }
@@ -91,8 +90,6 @@ interface Command {
  */
 export class AssertTransformer {
 
-  static [TransformerId] = '@trv:test';
-
   /**
    * Resolves optoken to syntax kind.  Relies on `ts`
    */
@@ -162,7 +159,7 @@ export class AssertTransformer {
     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.getFilenameAsSrc(),
+        file: state.getFilenameIdentifier(),
         line: state.fromLiteral(ts.getLineAndCharacterOfPosition(state.source, node.getStart()).line + 1),
         text: state.fromLiteral(firstText),
         operator: state.fromLiteral(cmd.fn)
@@ -187,7 +184,7 @@ export class AssertTransformer {
       undefined,
       state.factory.createNodeArray([
         state.fromLiteral({
-          file: state.getFilenameAsSrc(),
+          file: state.getFilenameIdentifier(),
           line: state.fromLiteral(ts.getLineAndCharacterOfPosition(state.source, node.getStart()).line + 1),
           text: state.fromLiteral(`${key} ${firstText}`),
           operator: state.fromLiteral(`${key}`)
@@ -270,18 +267,23 @@ export class AssertTransformer {
     }
   }
 
+  @OnMethod('AssertCheck')
+  static onAssertCheck(state: TransformerState & AssertState, node: ts.MethodDeclaration): ts.MethodDeclaration {
+    state[IsTestⲐ] = true;
+    return node;
+  }
+
+  @AfterMethod('AssertCheck')
+  static afterAssertCheck(state: TransformerState & AssertState, node: ts.MethodDeclaration): ts.MethodDeclaration {
+    state[IsTestⲐ] = false;
+    return node;
+  }
+
   /**
    * Listen for all call expression
    */
   @OnCall()
   static onAssertCall(state: TransformerState & AssertState, node: ts.CallExpression): ts.CallExpression {
-    // If not in test mode, see if file is valid
-    if (state[IsTestⲐ] === undefined) {
-      const name = PathUtil.toUnix(state.source.fileName);
-      // Only apply to test files, allowing for inheriting from module test files as well
-      state[IsTestⲐ] = /\/test(-(support|isolated))?\//.test(name) && !name.includes('/test/src/');
-    }
-
     // Only check in test mode
     if (!state[IsTestⲐ]) {
       return node;
@@ -290,7 +292,7 @@ export class AssertTransformer {
     const exp = node.expression;
 
     // Determine if calling assert directly
-    if (ts.isIdentifier(exp) && exp.getText() === ASSERT_CMD) { // Straight assert
+    if (ts.isIdentifier(exp) && exp.getSourceFile() && exp.getText() === ASSERT_CMD) { // Straight assert
       const cmd = this.getCommand(state, node.arguments);
       if (cmd) {
         node = this.doAssert(state, node, cmd);