@travetto/test 7.0.0-rc.2 → 7.0.0-rc.4

package/src/registry/registry-adapter.ts

@@ -61,7 +61,7 @@ export class SuiteRegistryAdapter implements RegistryAdapter<SuiteConfig> {
 
   register(...data: Partial<SuiteConfig>[]): SuiteConfig {
     if (!this.#config) {
-      const lines = describeFunction(this.#cls)?.lines;
+      const { lines, hash } = describeFunction(this.#cls) ?? {};
       this.#config = asFull<SuiteConfig>({
         class: this.#cls,
         classId: this.#cls.Ⲑid,
@@ -69,6 +69,7 @@ export class SuiteRegistryAdapter implements RegistryAdapter<SuiteConfig> {
         import: Runtime.getImport(this.#cls),
         lineStart: lines?.[0],
         lineEnd: lines?.[1],
+        sourceHash: hash,
         tests: {},
         beforeAll: [],
         beforeEach: [],
@@ -84,7 +85,7 @@ export class SuiteRegistryAdapter implements RegistryAdapter<SuiteConfig> {
     const suite = this.register();
 
     if (!(method in this.#config.tests)) {
-      const lines = describeFunction(this.#cls)?.methods?.[method]?.lines;
+      const { lines, hash } = describeFunction(this.#cls)?.methods?.[method] ?? {};
       const config = asFull<TestConfig>({
         class: this.#cls,
         tags: [],
@@ -93,6 +94,7 @@ export class SuiteRegistryAdapter implements RegistryAdapter<SuiteConfig> {
         lineEnd: lines?.[1],
         lineBodyStart: lines?.[2],
         methodName: method,
+        sourceHash: hash,
       });
       this.#config.tests[method] = config;
     }

package/src/registry/registry-index.ts

@@ -1,5 +1,5 @@
 import { AppError, Class, Runtime, describeFunction } from '@travetto/runtime';
-import { ChangeEvent, RegistryIndex, RegistryIndexStore, Registry } from '@travetto/registry';
+import { RegistryIndex, RegistryIndexStore, Registry } from '@travetto/registry';
 
 import { SuiteConfig } from '../model/suite.ts';
 import { TestConfig, TestRun } from '../model/test.ts';
@@ -21,11 +21,7 @@ export class SuiteRegistryIndex implements RegistryIndex {
     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 {
+  static getTestConfig(cls: Class, method: Function | string): TestConfig | undefined {
     return this.#instance.getTestConfig(cls, method);
   }
 
@@ -41,11 +37,13 @@ export class SuiteRegistryIndex implements RegistryIndex {
     return this.#instance.store.getClasses();
   }
 
+  static hasConfig(cls: Class): boolean {
+    return this.#instance.store.has(cls);
+  }
+
   store = new RegistryIndexStore(SuiteRegistryAdapter);
 
-  process(_events: ChangeEvent<Class>[]): void {
-    // No-op for now
-  }
+  /** @private */ constructor(source: unknown) { Registry.validateConstructor(source); }
 
   /**
    * Find all valid tests (ignoring abstract)
@@ -109,10 +107,11 @@ export class SuiteRegistryIndex implements RegistryIndex {
   /**
    * Find a test configuration given class and optionally a method
    */
-  getTestConfig(cls: Class, method: Function): TestConfig | undefined {
+  getTestConfig(cls: Class, method: Function | string): TestConfig | undefined {
     if (this.store.has(cls)) {
       const config = this.getConfig(cls);
-      return Object.values(config.tests).find(item => item.methodName === method.name);
+      const methodName = typeof method === 'string' ? method : method.name;
+      return Object.values(config.tests).find(item => item.methodName === methodName);
     }
   }
 }

package/src/worker/child.ts

@@ -1,12 +1,12 @@
 import { createWriteStream } from 'node:fs';
 
-import { ConsoleManager, Env, Util, Runtime } from '@travetto/runtime';
+import { ConsoleManager, Env, Runtime } from '@travetto/runtime';
 import { IpcChannel } from '@travetto/worker';
 
-import { RunnerUtil } from '../execute/util.ts';
-import { Runner } from '../execute/runner.ts';
-import { Events } from './types.ts';
+import { RunUtil } from '../execute/run.ts';
+import { TestWorkerEvents } from './types.ts';
 import { TestRun } from '../model/test.ts';
+import { CommunicationUtil } from '../communication.ts';
 
 /**
  * Child Worker for the Test Runner.  Receives events as commands
@@ -25,7 +25,7 @@ export class TestChildWorker extends IpcChannel<TestRun> {
         throw error;
       }
       // Mark as errored out
-      this.send(type, JSON.parse(Util.serializeToJSON({ error })));
+      this.send(type, CommunicationUtil.serializeToObject({ error }));
     }
   }
 
@@ -42,13 +42,13 @@ export class TestChildWorker extends IpcChannel<TestRun> {
       ConsoleManager.set({ log: () => { } });
     }
 
-    RunnerUtil.registerCleanup('worker');
+    RunUtil.registerCleanup('worker');
 
     // Listen for inbound requests
     this.on('*', event => this.onCommand(event));
 
     // Let parent know the child is ready for handling commands
-    this.send(Events.READY);
+    this.send(TestWorkerEvents.READY);
 
     await this.#done.promise;
   }
@@ -59,10 +59,10 @@ export class TestChildWorker extends IpcChannel<TestRun> {
   async onCommand(event: TestRun & { type: string }): Promise<boolean> {
     console.debug('on message', { ...event });
 
-    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
-      await this.#exec(() => this.onRunCommand(event), Events.RUN_COMPLETE);
+    if (event.type === TestWorkerEvents.INIT) { // On request to init, start initialization
+      await this.#exec(() => this.onInitCommand(), TestWorkerEvents.INIT_COMPLETE);
+    } else if (event.type === TestWorkerEvents.RUN) { // On request to run, start running
+      await this.#exec(() => this.onRunCommand(event), TestWorkerEvents.RUN_COMPLETE);
     }
 
     return false;
@@ -80,7 +80,7 @@ export class TestChildWorker extends IpcChannel<TestRun> {
     console.debug('Running', { import: run.import });
 
     try {
-      await new Runner({ consumer: 'exec', target: run }).run();
+      await RunUtil.runTests({ consumer: 'exec' }, run);
     } finally {
       this.#done.resolve();
     }

package/src/worker/standard.ts

@@ -1,26 +1,26 @@
 import { fork } from 'node:child_process';
 
-import { Env, RuntimeIndex, Util } from '@travetto/runtime';
+import { Env, RuntimeIndex } from '@travetto/runtime';
 import { IpcChannel } from '@travetto/worker';
 
-import { Events, TestLogEvent } from './types.ts';
-import { TestConsumerShape } from '../consumer/types.ts';
-import { TestEvent } from '../model/event.ts';
-import { TestRun } from '../model/test.ts';
+import { TestWorkerEvents, type TestLogEvent } from './types.ts';
+import type { TestConsumerShape } from '../consumer/types.ts';
+import type { TestEvent, TestRemoveEvent } from '../model/event.ts';
+import type { TestDiffInput, TestRun } from '../model/test.ts';
+import { CommunicationUtil } from '../communication.ts';
 
-const log = (message: string): void => {
-  process.send?.({ type: 'log', message } satisfies TestLogEvent);
+const log = (message: string | TestLogEvent): void => {
+  const event: TestLogEvent = typeof message === 'string' ? { type: 'log', message } : message;
+  process.send ? process.send?.(event) : console.debug(event.message);
 };
 
 /**
  *  Produce a handler for the child worker
  */
-export async function buildStandardTestManager(consumer: TestConsumerShape, run: TestRun): Promise<void> {
+export async function buildStandardTestManager(consumer: TestConsumerShape, run: TestRun | TestDiffInput): Promise<void> {
   log(`Worker Input ${JSON.stringify(run)}`);
-  log(`Worker Executing ${run.import}`);
 
-  const { module } = RuntimeIndex.getFromImport(run.import)!;
-  const suiteMod = RuntimeIndex.getModule(module)!;
+  const suiteMod = RuntimeIndex.findModuleForArbitraryImport(run.import)!;
 
   const channel = new IpcChannel<TestEvent & { error?: Error }>(
     fork(
@@ -37,25 +37,34 @@ export async function buildStandardTestManager(consumer: TestConsumerShape, run:
     )
   );
 
-  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
+  await channel.once(TestWorkerEvents.READY); // Wait for the child to be ready
+  await channel.send(TestWorkerEvents.INIT); // Initialize
+  await channel.once(TestWorkerEvents.INIT_COMPLETE); // Wait for complete
 
   channel.on('*', async event => {
     try {
-      await consumer.onEvent(Util.deserializeFromJson(JSON.stringify(event)));  // Connect the consumer with the event stream from the child
+      const parsed: TestEvent | TestRemoveEvent | TestLogEvent = CommunicationUtil.deserializeFromObject(event);
+      if (parsed.type === 'log') {
+        log(parsed);
+      } else if (parsed.type === 'removeTest') {
+        log(`Received remove event ${JSON.stringify(event)}@${consumer.constructor.name}`);
+        await consumer.onRemoveEvent?.(parsed); // Forward remove events
+      } else {
+        await consumer.onEvent(parsed);  // Forward standard events
+      }
     } catch {
       // Do nothing
     }
   });
 
   // Listen for child to complete
-  const complete = channel.once(Events.RUN_COMPLETE);
+  const complete = channel.once(TestWorkerEvents.RUN_COMPLETE);
   // Start test
-  channel.send(Events.RUN, run);
+  channel.send(TestWorkerEvents.RUN, run);
 
   // Wait for complete
-  const result = await complete.then(event => Util.deserializeFromJson<typeof event>(JSON.stringify(event)));
+  const completedEvent = await complete;
+  const result: { error?: unknown } = await CommunicationUtil.deserializeFromObject(completedEvent);
 
   // Kill on complete
   await channel.destroy();

package/src/worker/types.ts

@@ -1,10 +1,9 @@
-import { TestEvent } from '../model/event.ts';
-import { TestRun } from '../model/test.ts';
+import { TestEvent, TestRemoveEvent } from '../model/event.ts';
 
 /**
  * Test Run Event Keys
  */
-export const Events = {
+export const TestWorkerEvents = {
   RUN: 'run',
   RUN_COMPLETE: 'runComplete',
   INIT: 'init',
@@ -12,12 +11,17 @@ export const Events = {
   READY: 'ready'
 };
 
-export type TestRemovedEvent = { type: 'removeTest', method?: string } & TestRun;
+export type TestRunEvent = { type: 'runTest', import: string };
+
+export const isTestRunEvent = (event: unknown): event is TestRunEvent =>
+  typeof event === 'object' && !!event && 'type' in event && event.type === 'runTest';
+
+
 export type TestReadyEvent = { type: 'ready' };
 export type TestLogEvent = { type: 'log', message: string };
 
 export type TestWatchEvent =
   TestEvent |
-  TestRemovedEvent |
+  TestRemoveEvent |
   TestReadyEvent |
   TestLogEvent;

package/support/bin/run.ts

@@ -2,20 +2,20 @@ import { getClass, Runtime } from '@travetto/runtime';
 import { SchemaRegistryIndex } from '@travetto/schema';
 
 import { TestConsumerRegistryIndex } from '../../src/consumer/registry-index.ts';
-import type { RunState } from '../../src/execute/types.ts';
+import type { TestConsumerConfig } from '../../src/execute/types.ts';
+import type { TestRunInput } from '../../src/model/test.ts';
 
 /**
  * Run tests given the input state
  * @param state
  */
-export async function runTests(state: RunState): Promise<void> {
-  const { RunnerUtil } = await import('../../src/execute/util.ts');
-  const { Runner } = await import('../../src/execute/runner.ts');
+export async function runTests(state: TestConsumerConfig, input: TestRunInput): Promise<void> {
+  const { RunUtil } = await import('../../src/execute/run.ts');
 
-  RunnerUtil.registerCleanup('runner');
+  RunUtil.registerCleanup('runner');
 
   try {
-    const result = await new Runner(state).run();
+    const result = await RunUtil.runTests(state, input);
     process.exitCode = result ? 0 : 1;
   } catch (error) {
     console.error('Test Worker Failed', { error });

package/support/cli.test.ts

@@ -1,9 +1,7 @@
 import { EventEmitter } from 'node:events';
-import fs from 'node:fs/promises';
-import path from 'node:path';
 
-import { Env } from '@travetto/runtime';
-import { CliCommandShape, CliCommand, CliValidationError } from '@travetto/cli';
+import { Env, RuntimeIndex } from '@travetto/runtime';
+import { CliCommandShape, CliCommand, CliUtil } from '@travetto/cli';
 import { WorkPool } from '@travetto/worker';
 import { Max, Min } from '@travetto/schema';
 
@@ -20,11 +18,8 @@ export class TestCommand implements CliCommandShape {
   @Min(1) @Max(WorkPool.MAX_SIZE)
   concurrency: number = WorkPool.DEFAULT_SIZE;
 
-  /** Test run mode */
-  mode: 'single' | 'standard' = 'standard';
-
   /**
-   * Tags to target or exclude
+   * Tags to target or exclude when using globs
    * @alias env.TRV_TEST_TAGS
    */
   tags?: string[];
@@ -44,46 +39,30 @@ export class TestCommand implements CliCommandShape {
     Env.TRV_LOG_TIME.clear();
   }
 
-  isFirstFile(first: string): Promise<boolean> {
-    return fs.stat(path.resolve(first ?? '')).then(stat => stat.isFile(), () => false);
-  }
-
-  async resolvedMode(first: string, rest: string[]): Promise<string> {
-    return (await this.isFirstFile(first)) && rest.length === 0 ? 'single' : this.mode;
-  }
-
   async preValidate(): Promise<void> {
     const { selectConsumer } = await import('./bin/run.ts');
     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)) {
-      return { message: 'You must specify a proper test file to run in single mode', source: 'arg' };
-    }
-  }
-
   async main(first: string = '**/*', globs: string[] = []): Promise<void> {
     const { runTests } = await import('./bin/run.ts');
 
-    const isFirst = await this.isFirstFile(first);
-    const isSingle = this.mode === 'single' || (isFirst && globs.length === 0);
-    const options = Object.fromEntries((this.formatOptions ?? [])?.map(option => [...option.split(':'), true]));
-
-    return runTests({
-      concurrency: this.concurrency,
-      consumer: this.format,
-      consumerOptions: options,
-      tags: this.tags,
-      target: isSingle ?
-        {
-          import: first,
-          classId: globs[0],
-          methodNames: globs.slice(1),
-        } :
-        { globs: [first, ...globs], }
-    });
+    const importPath = RuntimeIndex.getFromImportOrSource(first)?.import;
+
+    return runTests(
+      {
+        concurrency: this.concurrency,
+        consumer: this.format,
+        consumerOptions: CliUtil.readExtendedOptions(this.formatOptions),
+      },
+      importPath ? {
+        import: importPath,
+        classId: globs[0],
+        methodNames: globs.slice(1),
+      } : {
+        globs: [first, ...globs],
+        tags: this.tags,
+      }
+    );
   }
 }

package/support/cli.test_diff.ts

@@ -0,0 +1,47 @@
+import { Env, JSONUtil, RuntimeIndex } from '@travetto/runtime';
+import { CliCommand, CliUtil } from '@travetto/cli';
+import { IsPrivate } from '@travetto/schema';
+
+import { runTests, selectConsumer } from './bin/run.ts';
+import type { TestDiffSource } from '../src/model/test.ts';
+
+/**  Direct test invocation */
+@CliCommand()
+@IsPrivate()
+export class TestDiffCommand {
+
+  format: string = 'tap';
+
+  /**
+   * Format options
+   * @alias o
+   */
+  formatOptions?: string[];
+
+  async preValidate(): Promise<void> {
+    await selectConsumer(this);
+  }
+
+  preMain(): void {
+    Env.TRV_ROLE.set('test');
+    Env.TRV_ENV.set('test');
+    Env.TRV_LOG_PLAIN.set(true);
+    Env.TRV_LOG_TIME.clear();
+  }
+
+  async main(importOrFile: string, diff: string): Promise<void> {
+    const diffSource: TestDiffSource = await JSONUtil.readFile(diff);
+    const importPath = RuntimeIndex.getFromImportOrSource(importOrFile)?.import!;
+
+    return runTests(
+      {
+        consumer: this.format,
+        consumerOptions: CliUtil.readExtendedOptions(this.formatOptions),
+      },
+      {
+        import: importPath,
+        diffSource
+      }
+    );
+  }
+}

package/support/cli.test_digest.ts

@@ -4,7 +4,7 @@ import { Registry } from '@travetto/registry';
 import { IsPrivate } from '@travetto/schema';
 
 import { SuiteRegistryIndex } from '../src/registry/registry-index.ts';
-import { RunnerUtil } from '../src/execute/util.ts';
+import { RunUtil } from '../src/execute/run.ts';
 
 @CliCommand()
 @IsPrivate()
@@ -19,7 +19,7 @@ export class TestDigestCommand {
 
   async main(globs: string[] = ['**/*']) {
     // Load all tests
-    for await (const imp of await RunnerUtil.getTestImports(globs)) {
+    for await (const imp of await RunUtil.getTestImports(globs)) {
       try {
         await Runtime.importFrom(imp);
       } catch (error) {

package/support/cli.test_direct.ts

@@ -1,5 +1,5 @@
-import { Env } from '@travetto/runtime';
-import { CliCommand } from '@travetto/cli';
+import { Env, RuntimeIndex } from '@travetto/runtime';
+import { CliCommand, CliUtil } from '@travetto/cli';
 import { IsPrivate } from '@travetto/schema';
 
 import { runTests, selectConsumer } from './bin/run.ts';
@@ -9,7 +9,6 @@ import { runTests, selectConsumer } from './bin/run.ts';
 @IsPrivate()
 export class TestDirectCommand {
 
-  @IsPrivate()
   format: string = 'tap';
 
   /**
@@ -30,17 +29,19 @@ export class TestDirectCommand {
   }
 
   main(importOrFile: string, clsId?: string, methodsNames: string[] = []): Promise<void> {
-
-    const options = Object.fromEntries((this.formatOptions ?? [])?.map(option => [...option.split(':'), true]));
-
-    return runTests({
-      consumer: this.format,
-      consumerOptions: options,
-      target: {
-        import: importOrFile,
+    // Resolve to import
+    const importPath = RuntimeIndex.getFromImportOrSource(importOrFile)?.import!;
+
+    return runTests(
+      {
+        consumer: this.format,
+        consumerOptions: CliUtil.readExtendedOptions(this.formatOptions),
+      },
+      {
+        import: importPath,
         classId: clsId,
         methodNames: methodsNames,
       }
-    });
+    );
   }
 }

package/support/cli.test_watch.ts

@@ -1,5 +1,5 @@
 import { Env } from '@travetto/runtime';
-import { CliCommand, CliUtil } from '@travetto/cli';
+import { CliCommand } from '@travetto/cli';
 
 import { selectConsumer } from './bin/run.ts';
 
@@ -18,14 +18,9 @@ export class TestWatcherCommand {
 
   preMain(): void {
     Env.TRV_ROLE.set('test');
-    Env.TRV_DYNAMIC.set(true);
   }
 
   async main(): Promise<void> {
-    if (await CliUtil.runWithRestart(this, true)) {
-      return;
-    }
-
     try {
       const { TestWatcher } = await import('../src/execute/watcher.ts');
       await TestWatcher.watch(this.format, this.mode === 'all');

package/src/execute/runner.ts

@@ -1,87 +0,0 @@
-import path from 'node:path';
-
-import { TimeUtil, Runtime, RuntimeIndex } from '@travetto/runtime';
-import { WorkPool } from '@travetto/worker';
-
-import { buildStandardTestManager } from '../worker/standard.ts';
-import { RunnableTestConsumer } from '../consumer/types/runnable.ts';
-import { TestRun } from '../model/test.ts';
-
-import { TestExecutor } from './executor.ts';
-import { RunnerUtil } from './util.ts';
-import { RunState } from './types.ts';
-import { TestConsumerRegistryIndex } from '../consumer/registry-index.ts';
-
-/**
- * Test Runner
- */
-export class Runner {
-
-  #state: RunState;
-
-  constructor(state: RunState) {
-    this.#state = state;
-  }
-
-  /**
-   * Run all files
-   */
-  async runFiles(globs?: string[]): Promise<boolean> {
-    const target = await TestConsumerRegistryIndex.getInstance(this.#state);
-    const consumer = new RunnableTestConsumer(target);
-    const tests = await RunnerUtil.getTestDigest(globs, this.#state.tags);
-    const testRuns = RunnerUtil.getTestRuns(tests)
-      .toSorted((a, b) => a.runId!.localeCompare(b.runId!));
-
-    await consumer.onStart({ testCount: tests.length });
-    await WorkPool.run(
-      run => buildStandardTestManager(consumer, run),
-      testRuns,
-      {
-        idleTimeoutMillis: TimeUtil.asMillis(10, 's'),
-        min: 1,
-        max: this.#state.concurrency
-      });
-
-    return consumer.summarizeAsBoolean();
-  }
-
-  /**
-   * Run a single file
-   */
-  async runSingle(run: TestRun): Promise<boolean> {
-    run.import =
-      RuntimeIndex.getFromImport(run.import)?.import ??
-      RuntimeIndex.getFromSource(path.resolve(run.import))?.import!;
-
-    const entry = RuntimeIndex.getFromImport(run.import)!;
-
-    if (entry.module !== Runtime.main.name) {
-      RuntimeIndex.reinitForModule(entry.module);
-    }
-
-    const target = await TestConsumerRegistryIndex.getInstance(this.#state);
-
-    const consumer = new RunnableTestConsumer(target)
-      .withTransformer(event => {
-        // Copy run metadata to event
-        event.metadata = run.metadata;
-        return event;
-      });
-
-    await consumer.onStart({});
-    await new TestExecutor(consumer).execute(run);
-    return consumer.summarizeAsBoolean();
-  }
-
-  /**
-   * Run the runner, based on the inputs passed to the constructor
-   */
-  async run(): Promise<boolean | undefined> {
-    if ('import' in this.#state.target) {
-      return await this.runSingle(this.#state.target);
-    } else {
-      return await this.runFiles(this.#state.target.globs);
-    }
-  }
-}