@travetto/test 7.0.0-rc.1 → 7.0.0-rc.3

package/src/execute/watcher.ts

@@ -1,14 +1,14 @@
+import { ManifestModuleUtil } from '@travetto/manifest';
 import { Registry } from '@travetto/registry';
 import { WorkPool } from '@travetto/worker';
-import { AsyncQueue, Runtime, RuntimeIndex, castTo, describeFunction } from '@travetto/runtime';
+import { AsyncQueue, RuntimeIndex, TimeUtil, watchCompiler } from '@travetto/runtime';
 
 import { buildStandardTestManager } from '../worker/standard.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';
+import type { TestDiffInput, TestRun } from '../model/test.ts';
+import { RunUtil } from './run.ts';
+import { isTestRunEvent, type TestReadyEvent } from '../worker/types.ts';
 
 /**
  * Test Watcher.
@@ -25,78 +25,51 @@ export class TestWatcher {
 
     await Registry.init();
 
-    const events: TestRun[] = [];
+    const events: (TestRun | TestDiffInput)[] = [];
 
     if (runAllOnStart) {
-      const tests = await RunnerUtil.getTestDigest();
-      events.push(...RunnerUtil.getTestRuns(tests));
+      events.push(...await RunUtil.resolveGlobInput({ globs: [] }));
     }
 
-    const itr = new AsyncQueue(events);
+    const queue = new AsyncQueue(events);
     const consumer = new CumulativeSummaryConsumer(
       await TestConsumerRegistryIndex.getInstance({ consumer: format })
-    )
-      .withFilter(x => x.metadata?.partial !== true || x.type !== 'suite');
-
-    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 = 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 }
-          };
-          console.log('Triggering', run);
-          itr.add(run, true); // Shift to front
-        }
-      } else {
-        process.send?.({
-          type: 'removeTest',
-          methodNames: method?.name ? [method.name!] : undefined!,
-          method: method?.name,
-          classId,
-          import: Runtime.getImport(cls)
-        } satisfies TestRemovedEvent);
-      }
-    }, SuiteRegistryIndex);
-
-    // If a file is changed, but doesn't emit classes, re-run whole file
-    Registry.onNonClassChanges(imp => itr.add({ import: imp }));
+    );
 
-    process.on('message', ev => {
-      if (typeof ev === 'object' && ev && 'type' in ev && ev.type === 'run-test') {
-        console.log('Received message', ev);
-        // Legacy
-        if ('file' in ev && typeof ev.file === 'string') {
-          ev = { import: RuntimeIndex.getFromSource(ev.file)?.import! };
-        }
-        console.debug('Manually triggered', ev);
-        itr.add(castTo(ev), true);
+    process.on('message', event => {
+      if (isTestRunEvent(event)) {
+        queue.add(event, true);
       }
     });
 
     process.send?.({ type: 'ready' } satisfies TestReadyEvent);
 
-    await WorkPool.run(
+    const queueProcessor = WorkPool.run(
       buildStandardTestManager.bind(null, consumer),
-      itr,
+      queue,
       {
-        idleTimeoutMillis: 120000,
+        idleTimeoutMillis: TimeUtil.asMillis('2m'),
         min: 2,
         max: WorkPool.DEFAULT_SIZE
       }
     );
+
+    for await (const event of watchCompiler()) {
+      const fileType = ManifestModuleUtil.getFileType(event.file);
+      if (
+        (fileType === 'ts' || fileType === 'js') &&
+        RuntimeIndex.findModuleForArbitraryFile(event.file) !== undefined
+      ) {
+        if (event.action === 'delete') {
+          consumer.removeTest(event.import);
+        } else {
+          const diffSource = consumer.produceDiffSource(event.import);
+          queue.add({ import: event.import, diffSource }, true);
+        }
+      }
+    }
+
+    // Cleanup
+    await queueProcessor;
   }
 }

package/src/fixture.ts

@@ -5,8 +5,8 @@ export class TestFixtures extends FileLoader {
     super([
       '@#test/fixtures',
       '@#support/fixtures',
-      ...modules.flat().map(x => `${x}#support/fixtures`),
+      ...modules.flat().map(mod => `${mod}#support/fixtures`),
       '@@#support/fixtures'
-    ].map(v => Runtime.modulePath(v)));
+    ].map(value => Runtime.modulePath(value)));
   }
 }

package/src/model/common.ts

@@ -29,6 +29,10 @@ export interface SuiteCore {
    * Description
    */
   description?: string;
+  /**
+   * Hash of the suite/test source code
+   */
+  sourceHash?: number;
 }
 
 /**

package/src/model/event.ts

@@ -14,6 +14,8 @@ export type EventPhase = 'before' | 'after';
 type EventTpl<T extends EventEntity, P extends EventPhase, V extends {}> =
   { type: T, phase: P, metadata?: Record<string, unknown> } & V;
 
+export type TestRemoveEvent = { type: 'removeTest', import: string, classId?: string, methodName?: string, metadata?: Record<string, unknown> };
+
 /**
  * Different test event shapes
  */
@@ -22,4 +24,4 @@ export type TestEvent =
   EventTpl<'test', 'before', { test: TestConfig }> |
   EventTpl<'test', 'after', { test: TestResult }> |
   EventTpl<'suite', 'before', { suite: SuiteConfig }> |
-  EventTpl<'suite', 'after', { suite: SuiteResult }>;
+  EventTpl<'suite', 'after', { suite: SuiteResult }>;

package/src/model/suite.ts

@@ -1,6 +1,6 @@
 import type { Class } from '@travetto/runtime';
 
-import { Assertion, TestConfig, TestResult } from './test.ts';
+import { Assertion, TestConfig, TestResult, type TestStatus } from './test.ts';
 import { Skip, SuiteCore } from './common.ts';
 
 /**
@@ -22,7 +22,7 @@ export interface SuiteConfig extends SuiteCore {
   /**
    * Tests to run
    */
-  tests: Record<string | symbol, TestConfig>;
+  tests: Record<string, TestConfig>;
   /**
    * Before all handlers
    */
@@ -48,37 +48,26 @@ export interface Counts {
   passed: number;
   skipped: number;
   failed: number;
+  unknown: number;
   total: number;
 }
 
 /**
  * Results of a suite run
  */
-export interface SuiteResult extends Counts {
+export interface SuiteResult extends Counts, SuiteCore {
   /**
-   * Class identifier
+   * All test results
    */
-  classId: string;
-  /**
-   * Import for the suite
-   */
-  import: string;
-  /**
-   * Start of the suite
-   */
-  lineStart: number;
-  /**
-   * End of the suite
-   */
-  lineEnd: number;
-  /**
-   * ALl test results
-   */
-  tests: TestResult[];
+  tests: Record<string, TestResult>;
   /**
    * Suite duration
    */
   duration: number;
+  /**
+   * Overall status
+   */
+  status: TestStatus;
 }
 
 /**

package/src/model/test.ts

@@ -2,9 +2,16 @@ import type { Class, ConsoleEvent, TimeSpan } from '@travetto/runtime';
 
 import { Skip, TestCore } from './common.ts';
 
-export type ThrowableError = string | RegExp | Class<Error> | ((e: Error | string) => boolean | void | undefined);
+export type ThrowableError = string | RegExp | Class<Error> | ((error: Error | string) => boolean | void | undefined);
 export type TestLog = Omit<ConsoleEvent, 'args' | 'scope'> & { message: string };
 
+export type TestDiffSource = Record<string, {
+  sourceHash: number;
+  methods: Record<string, number>;
+}>;
+
+export type TestStatus = 'passed' | 'skipped' | 'failed' | 'unknown';
+
 /**
  * Specific configuration for a test
  */
@@ -88,7 +95,7 @@ export interface TestResult extends TestCore {
   /**
    * status
    */
-  status: 'passed' | 'skipped' | 'failed';
+  status: TestStatus;
   /**
    * Error if failed
    */
@@ -136,3 +143,42 @@ export type TestRun = {
    */
   runId?: string;
 };
+
+/**
+ * Test Diff Input
+ */
+export type TestDiffInput = {
+  /**
+   * Import for run
+   */
+  import: string;
+  /**
+   * Diff Source
+   */
+  diffSource: TestDiffSource;
+  /**
+   * Test run metadata
+   */
+  metadata?: Record<string, unknown>;
+};
+
+/**
+ * Test Glob Input
+ */
+export type TestGlobInput = {
+  /**
+   * Globs to run
+   */
+  globs: string[];
+  /**
+   * Tags to filter by
+   */
+  tags?: string[];
+  /**
+   * Test run metadata
+   */
+  metadata?: Record<string, unknown>;
+};
+
+
+export type TestRunInput = TestRun | TestDiffInput | TestGlobInput;

package/src/model/util.ts

@@ -0,0 +1,8 @@
+import type { Counts } from './suite';
+import type { TestStatus } from './test';
+
+export class TestModelUtil {
+  static countsToTestStatus(counts: Counts): TestStatus {
+    return counts.failed ? 'failed' : (counts.passed ? 'passed' : counts.skipped ? 'skipped' : 'unknown');
+  }
+}

package/src/registry/registry-adapter.ts

@@ -6,24 +6,24 @@ 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];
+  for (const config of subConfig) {
+    if (config.beforeAll) {
+      baseConfig.beforeAll = [...baseConfig.beforeAll, ...config.beforeAll];
     }
-    if (cfg.beforeEach) {
-      baseConfig.beforeEach = [...baseConfig.beforeEach, ...cfg.beforeEach];
+    if (config.beforeEach) {
+      baseConfig.beforeEach = [...baseConfig.beforeEach, ...config.beforeEach];
     }
-    if (cfg.afterAll) {
-      baseConfig.afterAll = [...baseConfig.afterAll, ...cfg.afterAll];
+    if (config.afterAll) {
+      baseConfig.afterAll = [...baseConfig.afterAll, ...config.afterAll];
     }
-    if (cfg.afterEach) {
-      baseConfig.afterEach = [...baseConfig.afterEach, ...cfg.afterEach];
+    if (config.afterEach) {
+      baseConfig.afterEach = [...baseConfig.afterEach, ...config.afterEach];
     }
-    if (cfg.tags) {
-      baseConfig.tags = [...baseConfig.tags ?? [], ...cfg.tags];
+    if (config.tags) {
+      baseConfig.tags = [...baseConfig.tags ?? [], ...config.tags];
     }
-    if (cfg.tests) {
-      for (const [key, test] of Object.entries(cfg.tests ?? {})) {
+    if (config.tests) {
+      for (const [key, test] of Object.entries(config.tests ?? {})) {
         baseConfig.tests[key] = {
           ...test,
           sourceImport: Runtime.getImport(baseConfig.class),
@@ -40,11 +40,11 @@ function combineClasses(baseConfig: SuiteConfig, ...subConfig: Partial<SuiteConf
 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, {
+  for (const config of subConfig) {
+    safeAssign(baseConfig, config, {
       tags: [
         ...baseConfig.tags ?? [],
-        ...cfg.tags ?? []
+        ...config.tags ?? []
       ]
     });
   }
@@ -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: [],
@@ -80,11 +81,11 @@ export class SuiteRegistryAdapter implements RegistryAdapter<SuiteConfig> {
     return this.#config;
   }
 
-  registerTest(method: string | symbol, ...data: Partial<TestConfig>[]): TestConfig {
+  registerTest(method: string, ...data: Partial<TestConfig>[]): TestConfig {
     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: [],
@@ -92,7 +93,8 @@ export class SuiteRegistryAdapter implements RegistryAdapter<SuiteConfig> {
         lineStart: lines?.[0],
         lineEnd: lines?.[1],
         lineBodyStart: lines?.[2],
-        methodName: method.toString(),
+        methodName: method,
+        sourceHash: hash,
       });
       this.#config.tests[method] = config;
     }
@@ -117,7 +119,7 @@ export class SuiteRegistryAdapter implements RegistryAdapter<SuiteConfig> {
     return this.#config;
   }
 
-  getMethod(method: string | symbol): TestConfig {
+  getMethod(method: string): TestConfig {
     const test = this.#config.tests[method];
     if (!test) {
       throw new AppError(`Test not registered: ${String(method)} on ${this.#cls.name}`);

package/src/registry/registry-index.ts

@@ -1,12 +1,12 @@
 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';
 import { SuiteRegistryAdapter } from './registry-adapter.ts';
 
-const sortedTests = (cfg: SuiteConfig): TestConfig[] =>
-  Object.values(cfg.tests).toSorted((a, b) => a.lineStart - b.lineStart);
+const sortedTests = (config: SuiteConfig): TestConfig[] =>
+  Object.values(config.tests).toSorted((a, b) => a.lineStart - b.lineStart);
 
 type SuiteTests = { suite: SuiteConfig, tests: TestConfig[] };
 
@@ -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,17 +37,19 @@ 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)
    */
   getValidClasses(): Class[] {
-    return this.store.getClasses().filter(c => !describeFunction(c).abstract);
+    return this.store.getClasses().filter(cls => !describeFunction(cls).abstract);
   }
 
   getConfig(cls: Class): SuiteConfig {
@@ -70,27 +68,28 @@ export class SuiteRegistryIndex implements RegistryIndex {
       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);
+        .map(cls => this.getConfig(cls))
+        .filter(config => !config.skip);
+      const suite = suites.find(config => line >= config.lineStart && line <= config.lineEnd);
 
       if (suite) {
         const tests = sortedTests(suite);
-        const test = tests.find(x => line >= x.lineStart && line <= x.lineEnd);
+        const test = tests.find(config => line >= config.lineStart && line <= config.lineEnd);
         return test ? [{ suite, tests: [test] }] : [{ suite, tests }];
       } else {
-        return suites.map(x => ({ suite: x, tests: sortedTests(x) }));
+        return suites.map(config => ({ suite: config, tests: sortedTests(config) }));
       }
     } else { // Else lookup directly
       if (methodNames.length) {
-        const cls = this.getValidClasses().find(x => x.Ⲑid === clsId);
+        const cls = this.getValidClasses().find(type => type.Ⲑ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));
+        const tests = sortedTests(suite).filter(config => methodNames.includes(config.methodName));
         return [{ suite, tests }];
       } else if (clsId) {
-        const cls = this.getValidClasses().find(x => x.Ⲑid === clsId)!;
+        const cls = this.getValidClasses().find(type => type.Ⲑid === clsId)!;
         if (!cls) {
           throw new AppError('Unable to find suite for class ID', { details: { classId: clsId } });
         }
@@ -98,9 +97,9 @@ export class SuiteRegistryIndex implements RegistryIndex {
         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) }));
+          .map(type => this.getConfig(type))
+          .filter(config => !describeFunction(config.class).abstract);  // Do not run abstract suites
+        return suites.map(config => ({ suite: config, tests: sortedTests(config) }));
       }
     }
   }
@@ -108,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 conf = this.getConfig(cls);
-      return Object.values(conf.tests).find(x => x.methodName === method.name);
+      const config = this.getConfig(cls);
+      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
@@ -16,16 +16,16 @@ export class TestChildWorker extends IpcChannel<TestRun> {
 
   #done = Promise.withResolvers<void>();
 
-  async #exec(op: () => Promise<unknown>, type: string): Promise<void> {
+  async #exec(operation: () => Promise<unknown>, type: string): Promise<void> {
     try {
-      await op();
+      await operation();
       this.send(type); // Respond
-    } catch (err) {
-      if (!(err instanceof Error)) {
-        throw err;
+    } catch (error) {
+      if (!(error instanceof Error)) {
+        throw error;
       }
       // Mark as errored out
-      this.send(type, JSON.parse(Util.serializeToJSON({ error: err })));
+      this.send(type, CommunicationUtil.serializeToObject({ error }));
     }
   }
 
@@ -33,22 +33,22 @@ export class TestChildWorker extends IpcChannel<TestRun> {
    * Start the worker
    */
   async activate(): Promise<void> {
-    if (/\b@travetto[/]test\b/.test(Env.DEBUG.val ?? '')) {
+    if (/\b@travetto[/]test\b/.test(Env.DEBUG.value ?? '')) {
       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) });
+      const cons = new console.Console({ stdout, inspectOptions: { depth: 4, colors: false } });
+      ConsoleManager.set({ log: (event) => cons[event.level](process.pid, ...event.args) });
     } else {
       ConsoleManager.set({ log: () => { } });
     }
 
-    RunnerUtil.registerCleanup('worker');
+    RunUtil.registerCleanup('worker');
 
     // Listen for inbound requests
-    this.on('*', ev => this.onCommand(ev));
+    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();
     }