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

package/src/consumer/types/cumulative.ts

@@ -1,13 +1,18 @@
-import { existsSync } from 'node:fs';
-
-import { type Class, RuntimeIndex } from '@travetto/runtime';
-
 import type { TestConsumerShape } from '../types.ts';
-import type { TestEvent } from '../../model/event.ts';
-import type { TestResult } from '../../model/test.ts';
-import type { SuiteResult } from '../../model/suite.ts';
+import type { TestEvent, TestRemoveEvent } from '../../model/event.ts';
+import type { TestConfig, TestDiffSource, TestResult } from '../../model/test.ts';
+import type { Counts, SuiteConfig, SuiteResult } from '../../model/suite.ts';
 import { DelegatingConsumer } from './delegating.ts';
-import { SuiteRegistryIndex } from '../../registry/registry-index.ts';
+import { SuiteCore } from '../../model/common.ts';
+import { TestModelUtil } from '../../model/util.ts';
+
+type ClassId = string;
+type ImportName = string;
+
+type CumulativeTestResult = Pick<TestResult, 'sourceHash' | 'status' | 'duration'>;
+type CumulativeSuiteResult = Pick<SuiteCore, 'import' | 'classId' | 'sourceHash'> & {
+  tests: Record<string, CumulativeTestResult>;
+};
 
 /**
  * Cumulative Summary consumer
@@ -16,77 +21,101 @@ export class CumulativeSummaryConsumer extends DelegatingConsumer {
   /**
    * Total state of all tests run so far
    */
-  #state: Record<string, Record<string, TestResult['status']>> = {};
+  #state: Record<ImportName, Record<ClassId, CumulativeSuiteResult>> = {};
 
   constructor(target: TestConsumerShape) {
     super([target]);
   }
 
-  /**
-   * Summarize a given test suite using the new result and the historical
-   * state
-   */
-  summarizeSuite(test: TestResult): SuiteResult {
-    // Was only loading to verify existence (TODO: double-check)
-    if (existsSync(RuntimeIndex.getFromImport(test.import)!.sourceFile)) {
-      (this.#state[test.classId] ??= {})[test.methodName] = test.status;
-      const SuiteCls = SuiteRegistryIndex.getClasses().find(x => x.Ⲑid === test.classId);
-      return SuiteCls ? this.computeTotal(SuiteCls) : this.removeClass(test.classId);
-    } else {
-      return this.removeClass(test.classId);
+  getSuite(core: Pick<SuiteCore, 'import' | 'classId'>): CumulativeSuiteResult {
+    return this.#state[core.import]?.[core.classId];
+  }
+
+  getOrCreateSuite({ tests: _, ...core }: SuiteConfig | SuiteResult): CumulativeSuiteResult {
+    return (this.#state[core.import] ??= {})[core.classId] ??= { ...core, tests: {} };
+  }
+
+  onTestBefore(config: TestConfig): TestConfig {
+    const suite = this.getSuite(config);
+    suite.tests[config.methodName] = { sourceHash: config.sourceHash, status: 'unknown', duration: 0 };
+    return config;
+  }
+
+  onTestAfter(result: TestResult): TestResult {
+    const test = this.getSuite(result).tests[result.methodName];
+    Object.assign(test, { status: result.status, duration: result.duration });
+    return result;
+  }
+
+  onSuiteBefore(config: SuiteConfig): SuiteConfig {
+    const suite = this.getOrCreateSuite(config);
+    suite.sourceHash = config.sourceHash;
+    return config;
+  }
+
+  onSuiteAfter(result: SuiteResult): SuiteResult {
+    // Reset counts
+    const suite = this.getSuite(result);
+    const totals: Counts & { duration: number } = { passed: 0, failed: 0, skipped: 0, unknown: 0, total: 0, duration: 0 };
+    for (const test of Object.values(suite.tests)) {
+      totals[test.status] += 1;
+      totals.total += 1;
+      totals.duration += test.duration ?? 0;
     }
+    return { ...result, ...totals, status: TestModelUtil.countsToTestStatus(totals) };
   }
 
-  /**
-   * Remove a class
-   */
-  removeClass(clsId: string): SuiteResult {
-    this.#state[clsId] = {};
-    return {
-      classId: clsId, passed: 0, failed: 0, skipped: 0, total: 0, tests: [], duration: 0, import: '', lineStart: 0, lineEnd: 0
-    };
+  removeTest(importName: string, classId?: string, methodName?: string): void {
+    if (methodName && classId && importName) {
+      delete this.getSuite({ import: importName, classId }).tests[methodName];
+    } else if (classId && importName) {
+      delete this.#state[importName][classId];
+    } else if (importName) {
+      delete this.#state[importName];
+    }
+  }
+
+  transformRemove(event: TestRemoveEvent): TestRemoveEvent {
+    this.removeTest(event.import, event.classId, event.methodName);
+    return event;
   }
 
   /**
-   * Compute totals
+   * Handle cumulative events, and emit a summarized summary
    */
-  computeTotal(cls: Class): SuiteResult {
-    const suite = SuiteRegistryIndex.getConfig(cls);
-    const total = Object.values(suite.tests).reduce((acc, x) => {
-      const status = this.#state[x.classId][x.methodName] ?? 'unknown';
-      acc[status] += 1;
-      return acc;
-    }, { skipped: 0, passed: 0, failed: 0, unknown: 0 });
-
-    return {
-      classId: suite.classId,
-      passed: total.passed,
-      failed: total.failed,
-      skipped: total.skipped,
-      import: suite.import,
-      lineStart: suite.lineStart,
-      lineEnd: suite.lineEnd,
-      total: total.failed + total.passed,
-      tests: [],
-      duration: 0
-    };
+  transform(event: TestEvent): TestEvent | undefined {
+    try {
+      if (event.type === 'suite') {
+        if (event.phase === 'before') {
+          return { ...event, suite: this.onSuiteBefore(event.suite) };
+        } else if (event.phase === 'after') {
+          return { ...event, suite: this.onSuiteAfter(event.suite) };
+        }
+      } else if (event.type === 'test') {
+        if (event.phase === 'before') {
+          return { ...event, test: this.onTestBefore(event.test) };
+        } else if (event.phase === 'after') {
+          return { ...event, test: this.onTestAfter(event.test) };
+        }
+      }
+      return event;
+    } catch (error) {
+      console.warn('Summarization Error', { error });
+    }
   }
 
   /**
-   * Listen for event, process the full event, and if the event is an after test,
-   * send a full suite summary
+   * Produce diff source for import file
    */
-  onEventDone(e: TestEvent): void {
-    try {
-      if (e.type === 'test' && e.phase === 'after') {
-        this.onEvent({
-          type: 'suite',
-          phase: 'after',
-          suite: this.summarizeSuite(e.test),
-        });
+  produceDiffSource(importName: string): TestDiffSource {
+    const output: TestDiffSource = {};
+    for (const [clsId, suite] of Object.entries(this.#state[importName] || {})) {
+      const methods: TestDiffSource[string]['methods'] = {};
+      for (const [methodName, test] of Object.entries(suite.tests)) {
+        methods[methodName] = test.sourceHash!;
       }
-    } catch (err) {
-      console.warn('Summarization Error', { error: err });
+      output[clsId] = { sourceHash: suite.sourceHash!, methods };
     }
+    return output;
   }
 }

package/src/consumer/types/delegating.ts

@@ -1,58 +1,61 @@
 import type { SuitesSummary, TestConsumerShape, TestRunState } from '../types.ts';
-import type { TestEvent } from '../../model/event.ts';
+import type { TestEvent, TestRemoveEvent } from '../../model/event.ts';
 
 /**
  * Delegating event consumer
  */
 export abstract class DelegatingConsumer implements TestConsumerShape {
   #consumers: TestConsumerShape[];
-  #transformer?: (ev: TestEvent) => typeof ev;
-  #filter?: (ev: TestEvent) => boolean;
 
   constructor(consumers: TestConsumerShape[]) {
     this.#consumers = consumers;
-    for (const c of consumers) {
-      c.onEvent = c.onEvent.bind(c);
+    for (const consumer of consumers) {
+      consumer.onEvent = consumer.onEvent.bind(consumer);
     }
   }
 
-  withTransformer(transformer: (ev: TestEvent) => typeof ev): this {
-    this.#transformer = transformer;
-    return this;
+  async onStart(state: TestRunState): Promise<void> {
+    for (const consumer of this.#consumers) {
+      await consumer.onStart?.(state);
+    }
   }
 
-  withFilter(filter: (ev: TestEvent) => boolean): this {
-    this.#filter = filter;
-    return this;
+  onRemoveEvent(event: TestRemoveEvent): void {
+    let result = event;
+    if (this.transformRemove) {
+      result = this.transformRemove(event) ?? event;
+    }
+    if (result) {
+      for (const consumer of this.#consumers) {
+        consumer.onRemoveEvent?.(result);
+      }
+    }
   }
 
-  async onStart(state: TestRunState): Promise<void> {
-    for (const c of this.#consumers) {
-      await c.onStart?.(state);
+  delegateEvent(event: TestEvent): void {
+    for (const consumer of this.#consumers) {
+      consumer.onEvent(event);
     }
   }
 
-  onEvent(e: TestEvent): void {
-    if (this.#transformer) {
-      e = this.#transformer(e);
+  onEvent(event: TestEvent): void {
+    let result = event;
+    if (this.transform) {
+      result = this.transform(event) ?? event;
     }
-    if (this.#filter?.(e) === false) {
-      return;
+    if (result) {
+      this.delegateEvent(result);
     }
-    for (const c of this.#consumers) {
-      c.onEvent(e);
-    }
-
-    this.onEventDone?.(e);
   }
 
   async summarize(summary?: SuitesSummary): Promise<void> {
     if (summary) {
-      for (const c of this.#consumers) {
-        await c.onSummary?.(summary);
+      for (const consumer of this.#consumers) {
+        await consumer.onSummary?.(summary);
       }
     }
   }
 
-  onEventDone?(e: TestEvent): void;
+  transform?(event: TestEvent): TestEvent | undefined;
+  transformRemove?(event: TestRemoveEvent): TestRemoveEvent | undefined;
 }

package/src/consumer/types/event.ts

@@ -1,10 +1,9 @@
 import { Writable } from 'node:stream';
 
-import { Util } from '@travetto/runtime';
-
-import type { TestEvent } from '../../model/event.ts';
+import type { TestEvent, TestRemoveEvent } from '../../model/event.ts';
 import type { TestConsumerShape } from '../types.ts';
 import { TestConsumer } from '../decorator.ts';
+import { CommunicationUtil } from '../../communication.ts';
 
 /**
  * Streams all test events a JSON payload, in an nd-json format
@@ -17,7 +16,15 @@ export class EventStreamer implements TestConsumerShape {
     this.#stream = stream;
   }
 
+  sendPayload(payload: unknown): void {
+    this.#stream.write(`${CommunicationUtil.serialize(payload)}\n`);
+  }
+
   onEvent(event: TestEvent): void {
-    this.#stream.write(`${Util.serializeToJSON(event)}\n`);
+    this.sendPayload(event);
+  }
+
+  onRemoveEvent(event: TestRemoveEvent): void {
+    this.sendPayload(event);
   }
 }

package/src/consumer/types/exec.ts

@@ -1,16 +1,25 @@
 import { IpcChannel } from '@travetto/worker';
-import { Util } from '@travetto/runtime';
 
-import type { TestEvent } from '../../model/event.ts';
+import type { TestEvent, TestRemoveEvent } from '../../model/event.ts';
 import type { TestConsumerShape } from '../types.ts';
 import { TestConsumer } from '../decorator.ts';
+import { CommunicationUtil } from '../../communication.ts';
 
 /**
  * Triggers each event as an IPC command to a parent process
  */
 @TestConsumer()
 export class ExecutionEmitter extends IpcChannel<TestEvent> implements TestConsumerShape {
+
+  sendPayload(payload: unknown & { type: string }): void {
+    this.send(payload.type, CommunicationUtil.serializeToObject(payload));
+  }
+
   onEvent(event: TestEvent): void {
-    this.send(event.type, JSON.parse(Util.serializeToJSON(event)));
+    this.sendPayload(event);
+  }
+
+  onRemoveEvent(event: TestRemoveEvent): void {
+    this.sendPayload(event);
   }
 }

package/src/consumer/types/runnable.ts

@@ -12,11 +12,12 @@ export class RunnableTestConsumer extends DelegatingConsumer {
 
   constructor(...consumers: TestConsumerShape[]) {
     super(consumers);
-    this.#results = consumers.find(x => !!x.onSummary) ? new TestResultsSummarizer() : undefined;
+    this.#results = consumers.find(consumer => !!consumer.onSummary) ? new TestResultsSummarizer() : undefined;
   }
 
-  onEventDone(e: TestEvent): void {
-    this.#results?.onEvent(e);
+  transform(event: TestEvent): TestEvent | undefined {
+    this.#results?.onEvent(event);
+    return event;
   }
 
   async summarizeAsBoolean(): Promise<boolean> {

package/src/consumer/types/summarizer.ts

@@ -11,27 +11,29 @@ export class TestResultsSummarizer implements TestConsumerShape {
     passed: 0,
     failed: 0,
     skipped: 0,
+    unknown: 0,
     total: 0,
     duration: 0,
     suites: [],
     errors: []
   };
 
-  #merge(src: SuiteResult): void {
-    this.summary.suites.push(src);
-    this.summary.failed += src.failed;
-    this.summary.passed += src.passed;
-    this.summary.skipped += src.skipped;
-    this.summary.duration += src.duration;
-    this.summary.total += (src.failed + src.passed + src.skipped);
+  #merge(result: SuiteResult): void {
+    this.summary.suites.push(result);
+    this.summary.failed += result.failed;
+    this.summary.passed += result.passed;
+    this.summary.unknown += result.unknown;
+    this.summary.skipped += result.skipped;
+    this.summary.duration += result.duration;
+    this.summary.total += result.total;
   }
 
   /**
    * Merge all test results into a single Suite Result
    */
-  onEvent(e: TestEvent): void {
-    if (e.phase === 'after' && e.type === 'suite') {
-      this.#merge(e.suite);
+  onEvent(event: TestEvent): void {
+    if (event.type === 'suite' && event.phase === 'after') {
+      this.#merge(event.suite);
     }
   }
 }

package/src/consumer/types/tap-summary.ts

@@ -56,7 +56,7 @@ export class TapSummaryEmitter implements TestConsumerShape {
     const success = StyleUtil.getStyle({ text: '#e5e5e5', background: '#026020' }); // White on dark green
     const fail = StyleUtil.getStyle({ text: '#e5e5e5', background: '#8b0000' }); // White on dark red
     this.#progress = this.#terminal.streamToBottom(
-      Util.mapAsyncItr(
+      Util.mapAsyncIterable(
         this.#results,
         (value) => {
           failed += (value.status === 'failed' ? 1 : 0);
@@ -70,22 +70,22 @@ export class TapSummaryEmitter implements TestConsumerShape {
     );
   }
 
-  onEvent(ev: TestEvent): void {
-    if (ev.type === 'test' && ev.phase === 'after') {
-      const { test } = ev;
+  onEvent(event: TestEvent): void {
+    if (event.type === 'test' && event.phase === 'after') {
+      const { test } = event;
       this.#results.add(test);
       if (test.status === 'failed') {
-        this.#consumer.onEvent(ev);
+        this.#consumer.onEvent(event);
       }
       const tests = this.#timings.get('test')!;
-      tests.set(`${ev.test.classId}/${ev.test.methodName}`, {
-        key: `${ev.test.classId}/${ev.test.methodName}`,
+      tests.set(`${event.test.classId}/${event.test.methodName}`, {
+        key: `${event.test.classId}/${event.test.methodName}`,
         duration: test.duration,
         tests: 1
       });
-    } else if (ev.type === 'suite' && ev.phase === 'after') {
-      const [module] = ev.suite.classId.split(/:/);
-      const [file] = ev.suite.classId.split(/#/);
+    } else if (event.type === 'suite' && event.phase === 'after') {
+      const [module] = event.suite.classId.split(/:/);
+      const [file] = event.suite.classId.split(/#/);
 
       const modules = this.#timings.get('module')!;
       const files = this.#timings.get('file')!;
@@ -99,16 +99,18 @@ export class TapSummaryEmitter implements TestConsumerShape {
         files.set(file, { key: file, duration: 0, tests: 0 });
       }
 
-      suites.set(ev.suite.classId, {
-        key: ev.suite.classId,
-        duration: ev.suite.duration,
-        tests: ev.suite.tests.length
+      const testCount = Object.keys(event.suite.tests).length;
+
+      suites.set(event.suite.classId, {
+        key: event.suite.classId,
+        duration: event.suite.duration,
+        tests: testCount
       });
 
-      files.get(file)!.duration += ev.suite.duration;
-      files.get(file)!.tests += ev.suite.tests.length;
-      modules.get(module)!.duration += ev.suite.duration;
-      modules.get(module)!.tests += ev.suite.tests.length;
+      files.get(file)!.duration += event.suite.duration;
+      files.get(file)!.tests += testCount;
+      modules.get(module)!.duration += event.suite.duration;
+      modules.get(module)!.tests += testCount;
     }
   }
 
@@ -127,8 +129,8 @@ export class TapSummaryEmitter implements TestConsumerShape {
         await this.#consumer.log(`${this.#enhancer.suiteName(`Top ${count} slowest ${title}s`)}: `);
         const top10 = [...results.values()].toSorted((a, b) => b.duration - a.duration).slice(0, count);
 
-        for (const x of top10) {
-          console.log(`  * ${this.#enhancer.testName(x.key)} - ${this.#enhancer.total(x.duration)}ms / ${this.#enhancer.total(x.tests)} tests`);
+        for (const result of top10) {
+          console.log(`  * ${this.#enhancer.testName(result.key)} - ${this.#enhancer.total(result.duration)}ms / ${this.#enhancer.total(result.tests)} tests`);
         }
         await this.#consumer.log('');
       }

package/src/consumer/types/tap.ts

@@ -48,10 +48,10 @@ export class TapEmitter implements TestConsumerShape {
   /**
    * Output supplemental data (e.g. logs)
    */
-  logMeta(obj: Record<string, unknown>): void {
+  logMeta(meta: Record<string, unknown>): void {
     const lineLength = this.#terminal.width - 5;
-    let body = stringify(obj, { lineWidth: lineLength, indent: 2 });
-    body = body.split('\n').map(x => `  ${x}`).join('\n');
+    let body = stringify(meta, { lineWidth: lineLength, indent: 2 });
+    body = body.split('\n').map(line => `  ${line}`).join('\n');
     this.log(`---\n${this.#enhancer.objectInspect(body)}\n...`);
   }
 
@@ -59,16 +59,16 @@ export class TapEmitter implements TestConsumerShape {
    * Error to string
    * @param error
    */
-  errorToString(err?: Error): string | undefined {
-    if (err && err.name !== 'AssertionError') {
-      if (err instanceof Error) {
-        let out = JSON.stringify(hasToJSON(err) ? err.toJSON() : err, null, 2);
-        if (this.#options?.verbose && err.stack) {
-          out = `${out}\n${err.stack}`;
+  errorToString(error?: Error): string | undefined {
+    if (error && error.name !== 'AssertionError') {
+      if (error instanceof Error) {
+        let out = JSON.stringify(hasToJSON(error) ? error.toJSON() : error, null, 2);
+        if (this.#options?.verbose && error.stack) {
+          out = `${out}\n${error.stack}`;
         }
         return out;
       } else {
-        return `${err}`;
+        return `${error}`;
       }
     }
   }
@@ -76,9 +76,9 @@ export class TapEmitter implements TestConsumerShape {
   /**
    * Listen for each event
    */
-  onEvent(e: TestEvent): void {
-    if (e.type === 'test' && e.phase === 'after') {
-      const { test } = e;
+  onEvent(event: TestEvent): void {
+    if (event.type === 'test' && event.phase === 'after') {
+      const { test } = event;
       const suiteId = this.#enhancer.suiteName(test.classId);
       let header = `${suiteId} - ${this.#enhancer.testName(test.methodName)}`;
       if (test.description) {
@@ -155,8 +155,8 @@ export class TapEmitter implements TestConsumerShape {
 
     if (summary.errors.length) {
       this.log('---\n');
-      for (const err of summary.errors) {
-        const msg = this.errorToString(err);
+      for (const error of summary.errors) {
+        const msg = this.errorToString(error);
         if (msg) {
           this.log(this.#enhancer.failure(msg));
         }

package/src/consumer/types/xunit.ts

@@ -24,19 +24,19 @@ export class XunitEmitter implements TestConsumerShape {
   /**
    * Process metadata information (e.g. logs)
    */
-  buildMeta(obj: Record<string, unknown>): string {
-    if (!obj) {
+  buildMeta(meta: Record<string, unknown>): string {
+    if (!meta) {
       return '';
     }
 
-    for (const k of Object.keys(obj)) {
-      if (!obj[k]) {
-        delete obj[k];
+    for (const key of Object.keys(meta)) {
+      if (!meta[key]) {
+        delete meta[key];
       }
     }
-    if (Object.keys(obj).length) {
-      let body = stringify(obj);
-      body = body.split('\n').map(x => `  ${x}`).join('\n');
+    if (Object.keys(meta).length) {
+      let body = stringify(meta);
+      body = body.split('\n').map(line => `  ${line}`).join('\n');
       return `<![CDATA[\n${body}\n]]>`;
     } else {
       return '';
@@ -46,10 +46,10 @@ export class XunitEmitter implements TestConsumerShape {
   /**
    * Handle each test event
    */
-  onEvent(e: TestEvent): void {
-    if (e.type === 'test' && e.phase === 'after') {
+  onEvent(event: TestEvent): void {
+    if (event.type === 'test' && event.phase === 'after') {
 
-      const { test } = e;
+      const { test } = event;
 
       let name = `${test.methodName}`;
       if (test.description) {
@@ -59,8 +59,8 @@ export class XunitEmitter implements TestConsumerShape {
       let body = '';
 
       if (test.error) {
-        const assertErr = test.assertions.find(x => !!x.error)!;
-        body = `<failure type="${assertErr.text}" message="${encodeURIComponent(assertErr.message!)}"><![CDATA[${assertErr.error!.stack}]]></failure>`;
+        const assertion = test.assertions.find(item => !!item.error)!;
+        body = `<failure type="${assertion.text}" message="${encodeURIComponent(assertion.message!)}"><![CDATA[${assertion.error!.stack}]]></failure>`;
       }
 
       const groupedByLevel: Record<string, string[]> = {};
@@ -79,8 +79,8 @@ export class XunitEmitter implements TestConsumerShape {
       <system-err>${this.buildMeta({ error: groupedByLevel.error, warn: groupedByLevel.warn })}</system-err>
     </testcase>`
       );
-    } else if (e.type === 'suite' && e.phase === 'after') {
-      const { suite } = e;
+    } else if (event.type === 'suite' && event.phase === 'after') {
+      const { suite } = event;
       const testBodies = this.#tests.slice(0);
       this.#tests = [];
 

package/src/consumer/types.ts

@@ -1,7 +1,7 @@
 import { Class } from '@travetto/runtime';
 
-import { TestEvent } from '../model/event.ts';
-import { Counts, SuiteResult } from '../model/suite.ts';
+import type { TestEvent, TestRemoveEvent } from '../model/event.ts';
+import type { Counts, SuiteResult } from '../model/suite.ts';
 
 /**
  * All suite results
@@ -52,6 +52,10 @@ export interface TestConsumerShape {
    * Handle individual tests events
    */
   onEvent(event: TestEvent): void;
+  /**
+   * Handle when a remove event is fired
+   */
+  onRemoveEvent?(event: TestRemoveEvent): void;
   /**
    * Summarize all results
    */

package/src/decorator/suite.ts

@@ -15,7 +15,7 @@ export function Suite(): ClassDecorator;
 export function Suite(...rest: Partial<SuiteConfig>[]): ClassDecorator;
 export function Suite(description: string, ...rest: Partial<SuiteConfig>[]): ClassDecorator;
 export function Suite(description?: string | Partial<SuiteConfig>, ...rest: Partial<SuiteConfig>[]): ClassDecorator {
-  const dec = (cls: Class): typeof cls => {
+  const decorator = (cls: Class): typeof cls => {
     const isAbstract = describeFunction(cls).abstract;
     SuiteRegistryIndex.getForRegister(cls).register(
       ...(typeof description !== 'string' && description ? [description] : []),
@@ -26,7 +26,7 @@ export function Suite(description?: string | Partial<SuiteConfig>, ...rest: Part
     return cls;
   };
 
-  return castTo(dec);
+  return castTo(decorator);
 }
 
 /**