@travetto/test 5.0.0-rc.9 → 5.0.0

package/README.md

@@ -221,12 +221,13 @@ To run the tests you can either call the [Command Line Interface](https://github
 ```bash
 $ trv test --help
 
-Usage: test [options] [first:string] [regexes...:string]
+Usage: test [options] [first:string] [globs...:string]
 
 Options:
   -f, --format <string>         Output format for test results (default: "tap")
   -c, --concurrency <number>    Number of tests to run concurrently (default: 4)
   -m, --mode <single|standard>  Test run mode (default: "standard")
+  -t, --tags <string>           Tags to target or exclude
   -h, --help                    display help for command
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/test",
-  "version": "5.0.0-rc.9",
+  "version": "5.0.0",
   "description": "Declarative test framework",
   "keywords": [
     "unit-testing",
@@ -27,15 +27,15 @@
     "directory": "module/test"
   },
   "dependencies": {
-    "@travetto/runtime": "^5.0.0-rc.9",
-    "@travetto/registry": "^5.0.0-rc.9",
-    "@travetto/terminal": "^5.0.0-rc.9",
-    "@travetto/worker": "^5.0.0-rc.9",
-    "yaml": "^2.4.5"
+    "@travetto/registry": "^5.0.0",
+    "@travetto/runtime": "^5.0.0",
+    "@travetto/terminal": "^5.0.0",
+    "@travetto/worker": "^5.0.0",
+    "yaml": "^2.5.0"
   },
   "peerDependencies": {
-    "@travetto/cli": "^5.0.0-rc.9",
-    "@travetto/transformer": "^5.0.0-rc.6"
+    "@travetto/cli": "^5.0.0",
+    "@travetto/transformer": "^5.0.0"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/assert/check.ts

@@ -265,7 +265,7 @@ export class AssertCheck {
    * Look for any unhandled exceptions
    */
   static checkUnhandled(test: TestConfig, err: Error | assert.AssertionError): void {
-    let line = AssertUtil.getPositionOfError(err, test.import).line;
+    let line = AssertUtil.getPositionOfError(err, test.sourceImport ?? test.import).line;
     if (line === 1) {
       line = test.lineStart;
     }

package/src/assert/util.ts

@@ -1,9 +1,10 @@
 import util from 'node:util';
+import path from 'node:path';
 
-import { Runtime, RuntimeIndex } from '@travetto/runtime';
+import { asFull, Class, Runtime, RuntimeIndex } from '@travetto/runtime';
 
 import { TestConfig, Assertion, TestResult } from '../model/test';
-import { SuiteConfig } from '../model/suite';
+import { SuiteConfig, SuiteFailure, SuiteResult } from '../model/suite';
 
 function isCleanable(o: unknown): o is { toClean(): unknown } {
   return !!o && typeof o === 'object' && 'toClean' in o && typeof o.toClean === 'function';
@@ -18,6 +19,7 @@ export class AssertUtil {
    */
   static cleanValue(val: unknown): unknown {
     switch (typeof val) {
+      case 'number': case 'boolean': case 'bigint': case 'string': case 'undefined': return val;
       case 'object': {
         if (isCleanable(val)) {
           return val.toClean();
@@ -26,7 +28,6 @@ export class AssertUtil {
         }
         break;
       }
-      case 'undefined': case 'string': case 'number': case 'bigint': case 'boolean': return JSON.stringify(val);
       case 'function': {
         if (val.Ⲑid || !val.constructor) {
           return val.name;
@@ -87,7 +88,7 @@ export class AssertUtil {
   /**
    * Generate a suite error given a suite config, and an error
    */
-  static generateSuiteError(suite: SuiteConfig, methodName: string, error: Error): { assert: Assertion, testResult: TestResult, testConfig: TestConfig } {
+  static generateSuiteFailure(suite: SuiteConfig, methodName: string, error: Error): SuiteFailure {
     const { import: imp, ...pos } = this.getPositionOfError(error, suite.import);
     let line = pos.line;
 
@@ -108,11 +109,24 @@ export class AssertUtil {
       ...coreAll,
       status: 'failed', error, duration: 0, durationTotal: 0, assertions: [assert], output: {}
     };
-    const testConfig: TestConfig = {
+    const test: TestConfig = {
       ...coreAll,
       class: suite.class, skip: false
     };
 
-    return { assert, testResult, testConfig };
+    return { assert, testResult, test, suite };
+  }
+
+  /**
+   * Define import failure as a SuiteFailure object
+   */
+  static gernerateImportFailure(imp: string, err: Error): SuiteFailure {
+    const name = path.basename(imp);
+    const classId = `${RuntimeIndex.getFromImport(imp)?.id}￮${name}`;
+    const suite = asFull<SuiteConfig & SuiteResult>({
+      class: asFull<Class>({ name }), classId, duration: 0, lineStart: 1, lineEnd: 1, import: imp
+    });
+    err.message = err.message.replaceAll(Runtime.mainSourcePath, '.');
+    return this.generateSuiteFailure(suite, 'require', err);
   }
 }

package/src/consumer/{error.ts → serialize.ts}

@@ -5,11 +5,11 @@ import { TestEvent, } from '../model/event';
 
 export type SerializedError = { $?: boolean, message: string, stack?: string, name: string };
 
-function isSerialized(e: unknown): e is SerializedError {
+function isError(e: unknown): e is SerializedError {
   return !!e && (typeof e === 'object') && '$' in e;
 }
 
-export class ErrorUtil {
+export class SerializeUtil {
 
   /**
    *  Prepare error for transmission
@@ -41,7 +41,7 @@ export class ErrorUtil {
   static deserializeError(e: Error | SerializedError): Error;
   static deserializeError(e: undefined): undefined;
   static deserializeError(e: Error | SerializedError | undefined): Error | undefined {
-    if (isSerialized(e)) {
+    if (isError(e)) {
       const err = new Error();
 
       for (const k of TypedObject.keys(e)) {
@@ -54,25 +54,18 @@ export class ErrorUtil {
       err.stack = e.stack;
       err.name = e.name;
       return err;
-    } else if (e) {
+    } else {
       return e;
     }
   }
 
   /**
-   * Serialize all errors for a given test for transmission between parent/child
+   * Serialize to JSON
    */
-  static serializeTestErrors(out: TestEvent): void {
-    if (out.phase === 'after') {
-      if (out.type === 'test') {
-        if (out.test.error) {
-          out.test.error = this.serializeError(out.test.error);
-        }
-      } else if (out.type === 'assertion') {
-        if (out.assertion.error) {
-          out.assertion.error = this.serializeError(out.assertion.error);
-        }
-      }
-    }
+  static serializeToJSON(out: TestEvent): string {
+    return JSON.stringify(out, (_, v) =>
+      v instanceof Error ? this.serializeError(v) :
+        typeof v === 'bigint' ? v.toString() : v
+    );
   }
 }

package/src/consumer/types/cumulative.ts

@@ -7,19 +7,19 @@ import { TestEvent } from '../../model/event';
 import { TestResult } from '../../model/test';
 import { SuiteResult } from '../../model/suite';
 import { SuiteRegistry } from '../../registry/suite';
+import { DelegatingConsumer } from './delegating';
 
 /**
  * Cumulative Summary consumer
  */
-export class CumulativeSummaryConsumer implements TestConsumer {
+export class CumulativeSummaryConsumer extends DelegatingConsumer {
   /**
    * Total state of all tests run so far
    */
   #state: Record<string, Record<string, TestResult['status']>> = {};
-  #target: TestConsumer;
 
   constructor(target: TestConsumer) {
-    this.#target = target;
+    super([target]);
   }
 
   /**
@@ -29,16 +29,9 @@ export class CumulativeSummaryConsumer implements TestConsumer {
   summarizeSuite(test: TestResult): SuiteResult {
     // Was only loading to verify existence (TODO: double-check)
     if (existsSync(RuntimeIndex.getFromImport(test.import)!.sourceFile)) {
-      this.#state[test.classId] = this.#state[test.classId] ?? {};
-      this.#state[test.classId][test.methodName] = test.status;
-      const SuiteCls = SuiteRegistry.getClasses().find(x =>
-        x.Ⲑid === test.classId
-      )!;
-      if (SuiteCls) {
-        return this.computeTotal(SuiteCls);
-      } else {
-        return this.removeClass(test.classId);
-      }
+      (this.#state[test.classId] ??= {})[test.methodName] = test.status;
+      const SuiteCls = SuiteRegistry.getClasses().find(x => x.Ⲑid === test.classId);
+      return SuiteCls ? this.computeTotal(SuiteCls) : this.removeClass(test.classId);
     } else {
       return this.removeClass(test.classId);
     }
@@ -83,14 +76,13 @@ export class CumulativeSummaryConsumer implements TestConsumer {
    * Listen for event, process the full event, and if the event is an after test,
    * send a full suite summary
    */
-  onEvent(e: TestEvent): void {
-    this.#target.onEvent(e);
+  onEventDone(e: TestEvent): void {
     try {
       if (e.type === 'test' && e.phase === 'after') {
-        this.#target.onEvent({
+        this.onEvent({
           type: 'suite',
           phase: 'after',
-          suite: this.summarizeSuite(e.test)
+          suite: this.summarizeSuite(e.test),
         });
       }
     } catch (err) {

package/src/consumer/types/delegating.ts

@@ -0,0 +1,58 @@
+import { SuitesSummary, TestConsumer, TestRunState } from '../types';
+import { TestEvent } from '../../model/event';
+
+/**
+ * Delegating event consumer
+ */
+export abstract class DelegatingConsumer implements TestConsumer {
+  #consumers: TestConsumer[];
+  #transformer?: (ev: TestEvent) => typeof ev;
+  #filter?: (ev: TestEvent) => boolean;
+
+  constructor(consumers: TestConsumer[]) {
+    this.#consumers = consumers;
+    for (const c of consumers) {
+      c.onEvent = c.onEvent.bind(c);
+    }
+  }
+
+  withTransformer(transformer: (ev: TestEvent) => typeof ev): this {
+    this.#transformer = transformer;
+    return this;
+  }
+
+  withFilter(filter: (ev: TestEvent) => boolean): this {
+    this.#filter = filter;
+    return this;
+  }
+
+  async onStart(state: TestRunState): Promise<void> {
+    for (const c of this.#consumers) {
+      await c.onStart?.(state);
+    }
+  }
+
+  onEvent(e: TestEvent): void {
+    if (this.#transformer) {
+      e = this.#transformer(e);
+    }
+    if (this.#filter?.(e) === false) {
+      return;
+    }
+    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);
+      }
+    }
+  }
+
+  onEventDone?(e: TestEvent): void;
+}

package/src/consumer/types/event.ts

@@ -2,7 +2,7 @@ import { Writable } from 'node:stream';
 
 import { TestEvent } from '../../model/event';
 import { TestConsumer } from '../types';
-import { ErrorUtil } from '../error';
+import { SerializeUtil } from '../serialize';
 import { Consumable } from '../registry';
 
 /**
@@ -17,8 +17,6 @@ export class EventStreamer implements TestConsumer {
   }
 
   onEvent(event: TestEvent): void {
-    const out = { ...event };
-    ErrorUtil.serializeTestErrors(out);
-    this.#stream.write(`${JSON.stringify(out)}\n`);
+    this.#stream.write(`${SerializeUtil.serializeToJSON(event)}\n`);
   }
 }

package/src/consumer/types/execution.ts

@@ -2,7 +2,7 @@ import { ChildCommChannel } from '@travetto/worker';
 
 import { TestEvent } from '../../model/event';
 import { TestConsumer } from '../types';
-import { ErrorUtil } from '../error';
+import { SerializeUtil } from '../serialize';
 import { Consumable } from '../registry';
 
 /**
@@ -12,8 +12,6 @@ import { Consumable } from '../registry';
 export class ExecutionEmitter extends ChildCommChannel<TestEvent> implements TestConsumer {
 
   onEvent(event: TestEvent): void {
-    const out = { ...event };
-    ErrorUtil.serializeTestErrors(out);
-    this.send(event.type, out);
+    this.send(event.type, JSON.parse(SerializeUtil.serializeToJSON(event)));
   }
 }

package/src/consumer/types/runnable.ts

@@ -1,62 +1,33 @@
-import { TestConsumer, TestRunState } from '../types';
+import { TestConsumer } from '../types';
 import { TestResultsSummarizer } from './summarizer';
 import { TestConsumerRegistry } from '../registry';
 import { TestEvent } from '../../model/event';
+import { DelegatingConsumer } from './delegating';
 
 /**
  * Test consumer with support for multiple nested consumers, and summarization
  */
-export class RunnableTestConsumer implements TestConsumer {
+export class RunnableTestConsumer extends DelegatingConsumer {
   /**
    * Build a runnable test consumer given a format or a full consumer
    */
   static async get(consumer: string | TestConsumer): Promise<RunnableTestConsumer> {
-    return new RunnableTestConsumer(await TestConsumerRegistry.getInstance(consumer));
+    return new RunnableTestConsumer([await TestConsumerRegistry.getInstance(consumer)]);
   }
 
-  #consumers: TestConsumer[];
-  #results: TestResultsSummarizer | undefined;
+  #results?: TestResultsSummarizer;
 
-  constructor(...consumers: TestConsumer[]) {
-    this.#consumers = consumers;
-    for (const c of consumers) {
-      if (!this.#results && c.onSummary) { // If expecting summary
-        this.#results = new TestResultsSummarizer();
-      }
-      c.onEvent = c.onEvent.bind(c);
-    }
+  constructor(consumers: TestConsumer[]) {
+    super(consumers);
+    this.#results = consumers.find(x => !!x.onSummary) ? new TestResultsSummarizer() : undefined;
   }
 
-  async onStart(state: TestRunState): Promise<void> {
-    for (const c of this.#consumers) {
-      await c.onStart?.(state);
-    }
-  }
-
-  onEvent(e: TestEvent): void {
-    if (this.#results) {
-      this.#results.onEvent(e);
-    }
-    for (const c of this.#consumers) {
-      c.onEvent(e);
-    }
-  }
-
-  async summarize(): Promise<TestResultsSummarizer | undefined> {
-    if (this.#results) {
-      for (const c of this.#consumers) {
-        await c.onSummary?.(this.#results.summary);
-      }
-      return this.#results;
-    }
+  onEventDone(e: TestEvent): void {
+    this.#results?.onEvent(e);
   }
 
   async summarizeAsBoolean(): Promise<boolean> {
-    const result = await this.summarize();
-    if (result) {
-      return result.summary.failed <= 0;
-    } else {
-      return true;
-    }
+    await this.summarize(this.#results?.summary);
+    return (this.#results?.summary.failed ?? 0) <= 0;
   }
 }

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

@@ -1,6 +1,5 @@
-import { Util } from '@travetto/runtime';
+import { Util, AsyncQueue } from '@travetto/runtime';
 import { StyleUtil, Terminal, TerminalUtil } from '@travetto/terminal';
-import { WorkQueue } from '@travetto/worker';
 
 import { TestEvent } from '../../model/event';
 import { TestResult } from '../../model/test';
@@ -17,7 +16,7 @@ import { TapEmitter } from './tap';
 export class TapStreamedEmitter implements TestConsumer {
 
   #terminal: Terminal;
-  #results = new WorkQueue<TestResult>();
+  #results = new AsyncQueue<TestResult>();
   #progress: Promise<unknown> | undefined;
   #consumer: TapEmitter;
 
@@ -30,6 +29,8 @@ export class TapStreamedEmitter implements TestConsumer {
     this.#consumer.onStart();
 
     let failed = 0;
+    let skipped = 0;
+    let completed = 0;
     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(
@@ -37,7 +38,9 @@ export class TapStreamedEmitter implements TestConsumer {
         this.#results,
         (value, idx) => {
           failed += (value.status === 'failed' ? 1 : 0);
-          return { value: `Tests %idx/%total [${failed} failed] -- ${value.classId}`, total: state.testCount, idx };
+          skipped += (value.status === 'skipped' ? 1 : 0);
+          completed += (value.status !== 'skipped' ? 1 : 0);
+          return { value: `Tests %idx/%total [${failed} failed, ${skipped} skipped] -- ${value.classId}`, total: state.testCount, idx: completed };
         },
         TerminalUtil.progressBarUpdater(this.#terminal, { style: () => ({ complete: failed ? fail : success }) })
       ),

package/src/consumer/types/tap.ts

@@ -5,7 +5,7 @@ import { stringify } from 'yaml';
 import { TestEvent } from '../../model/event';
 import { SuitesSummary, TestConsumer } from '../types';
 import { Consumable } from '../registry';
-import { ErrorUtil } from '../error';
+import { SerializeUtil } from '../serialize';
 import { TestResultsEnhancer, CONSOLE_ENHANCER } from '../enhancer';
 
 /**
@@ -102,7 +102,7 @@ export class TapEmitter implements TestConsumer {
       // Handle error
       if (test.status === 'failed') {
         if (test.error && test.error.name !== 'AssertionError') {
-          const err = ErrorUtil.deserializeError(test.error);
+          const err = SerializeUtil.deserializeError(test.error);
           this.logMeta({ error: err instanceof AppError ? err.toJSON() : err });
         }
       }