@travetto/test 5.0.0-rc.0 → 5.0.0-rc.10

package/README.md

@@ -18,10 +18,10 @@ This module provides unit testing functionality that integrates with the framewo
    *  [JSON](https://www.json.org), best for integrating with at a code level
    *  [xUnit](https://en.wikipedia.org/wiki/XUnit), standard format for CI/CD systems e.g. Jenkins, Bamboo, etc.
 
-**Note**: All tests should be under the `test/.*` folders.  The pattern for tests is defined as a regex and not standard globbing.
+**Note**: All tests should be under the `**/*` folders.  The pattern for tests is defined as as a standard glob using [Node](https://nodejs.org)'s built in globbing support.
 
 ## Definition
-A test suite is a collection of individual tests.  All test suites are classes with the [@Suite](https://github.com/travetto/travetto/tree/main/module/test/src/decorator/suite.ts#L14) decorator. Tests are defined as methods on the suite class, using the [@Test](https://github.com/travetto/travetto/tree/main/module/test/src/decorator/test.ts#L19) decorator.  All tests intrinsically support `async`/`await`. 
+A test suite is a collection of individual tests.  All test suites are classes with the [@Suite](https://github.com/travetto/travetto/tree/main/module/test/src/decorator/suite.ts#L13) decorator. Tests are defined as methods on the suite class, using the [@Test](https://github.com/travetto/travetto/tree/main/module/test/src/decorator/test.ts#L20) decorator.  All tests intrinsically support `async`/`await`. 
 
 A simple example would be:
 
@@ -79,27 +79,25 @@ would translate to:
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-const Ⲑ_util_1 = tslib_1.__importStar(require("@travetto/test/src/execute/util.js"));
+const Ⲑ_debug_1 = tslib_1.__importStar(require("@travetto/runtime/src/debug.js"));
 const Ⲑ_check_1 = tslib_1.__importStar(require("@travetto/test/src/assert/check.js"));
-const Ⲑ_runtime_1 = tslib_1.__importStar(require("@travetto/manifest/src/runtime.js"));
-const Ⲑ_decorator_1 = tslib_1.__importStar(require("@travetto/registry/src/decorator.js"));
-var ᚕf = "@travetto/test/doc/assert-example.js";
+const Ⲑ_function_1 = tslib_1.__importStar(require("@travetto/runtime/src/function.js"));
+var ᚕm = ["@travetto/test", "doc/assert-example.ts"];
 const node_assert_1 = tslib_1.__importDefault(require("node:assert"));
 const test_1 = require("@travetto/test");
 let SimpleTest = class SimpleTest {
-    static Ⲑinit = Ⲑ_runtime_1.RuntimeIndex.registerFunction(SimpleTest, ᚕf, { hash: 1887908328, lines: [5, 12] }, { test: { hash: 102834457, lines: [8, 11] } }, false, false);
+    static Ⲑinit = Ⲑ_function_1.registerFunction(SimpleTest, ᚕm, { hash: 1887908328, lines: [5, 12] }, { test: { hash: 102834457, lines: [8, 11, 10] } }, false, false);
     async test() {
-        if (Ⲑ_util_1.RunnerUtil.tryDebugger)
+        if (Ⲑ_debug_1.tryDebugger)
             debugger;
-        Ⲑ_check_1.AssertCheck.check({ file: ᚕf, line: 10, text: "{ size: 20, address: { state: 'VA' } }", operator: "deepStrictEqual" }, true, { size: 20, address: { state: 'VA' } }, {});
+        Ⲑ_check_1.AssertCheck.check({ module: ᚕm, line: 10, text: "{ size: 20, address: { state: 'VA' } }", operator: "deepStrictEqual" }, true, { size: 20, address: { state: 'VA' } }, {});
     }
 };
 tslib_1.__decorate([
-    (0, test_1.Test)({ ident: "@Test()", lineBodyStart: 10 })
+    (0, test_1.Test)()
 ], SimpleTest.prototype, "test", null);
 SimpleTest = tslib_1.__decorate([
-    Ⲑ_decorator_1.Register(),
-    (0, test_1.Suite)({ ident: "@Suite()" })
+    (0, test_1.Suite)()
 ], SimpleTest);
 ```
 
@@ -223,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.0",
+  "version": "5.0.0-rc.10",
   "description": "Declarative test framework",
   "keywords": [
     "unit-testing",
@@ -27,15 +27,15 @@
     "directory": "module/test"
   },
   "dependencies": {
-    "@travetto/base": "^5.0.0-rc.0",
-    "@travetto/registry": "^5.0.0-rc.0",
-    "@travetto/terminal": "^5.0.0-rc.0",
-    "@travetto/worker": "^5.0.0-rc.0",
-    "yaml": "^2.4.5"
+    "@travetto/registry": "^5.0.0-rc.10",
+    "@travetto/runtime": "^5.0.0-rc.10",
+    "@travetto/terminal": "^5.0.0-rc.10",
+    "@travetto/worker": "^5.0.0-rc.10",
+    "yaml": "^2.5.0"
   },
   "peerDependencies": {
-    "@travetto/cli": "^5.0.0-rc.0",
-    "@travetto/transformer": "^5.0.0-rc.0"
+    "@travetto/cli": "^5.0.0-rc.11",
+    "@travetto/transformer": "^5.0.0-rc.7"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/assert/capture.ts

@@ -3,7 +3,7 @@ import { EventEmitter } from 'node:events';
 import { Assertion, TestConfig } from '../model/test';
 
 export interface CaptureAssert extends Partial<Assertion> {
-  file: string;
+  module?: [string, string];
   line: number;
   text: string;
   operator: string;
@@ -26,14 +26,15 @@ class $AssertCapture {
 
     // Emit and collect, every assertion as it occurs
     const handler = (a: CaptureAssert): void => {
-      const assrt = {
+      const asrt: Assertion = {
         ...a,
+        import: a.import ?? a.module!.join('/'),
         classId: test.classId,
         methodName: test.methodName
       };
-      assertions.push(assrt);
+      assertions.push(asrt);
       if (listener) {
-        listener(assrt);
+        listener(asrt);
       }
     };
 

package/src/assert/check.ts

@@ -1,7 +1,6 @@
 import assert from 'node:assert';
 
-import { RuntimeIndex } from '@travetto/manifest';
-import { AppError, ClassInstance, Class } from '@travetto/base';
+import { AppError, Class, castTo, castKey, asConstructable } from '@travetto/runtime';
 
 import { ThrowableError, TestConfig, Assertion } from '../model/test';
 import { AssertCapture, CaptureAssert } from './capture';
@@ -24,9 +23,6 @@ export class AssertCheck {
    * @param args The arguments passed in
    */
   static check(assertion: CaptureAssert, positive: boolean, ...args: unknown[]): void {
-    /* eslint-disable @typescript-eslint/consistent-type-assertions */
-    assertion.file = RuntimeIndex.getSourceFile(assertion.file);
-
     let fn = assertion.operator;
     assertion.operator = ASSERT_FN_OPERATOR[fn];
 
@@ -41,32 +37,32 @@ export class AssertCheck {
     // Check fn to call
     if (fn === 'fail') {
       if (args.length > 1) {
-        [assertion.actual, assertion.expected, assertion.message, assertion.operator] = args as [unknown, unknown, string, string];
+        [assertion.actual, assertion.expected, assertion.message, assertion.operator] = castTo(args);
       } else {
-        [assertion.message] = args as [string];
+        [assertion.message] = castTo(args);
       }
     } else if (/throw|reject/i.test(fn)) {
       assertion.operator = fn;
       if (typeof args[1] !== 'string') {
-        [, assertion.expected, assertion.message] = args as [unknown, unknown, string];
+        [, assertion.expected, assertion.message] = castTo(args);
       } else {
-        [, assertion.message] = args as [unknown, string];
+        [, assertion.message] = castTo(args);
       }
     } else if (fn === 'ok' || fn === 'assert') {
       fn = assertion.operator = 'ok';
-      [assertion.actual, assertion.message] = args as [unknown, string];
+      [assertion.actual, assertion.message] = castTo(args);
       assertion.expected = { toClean: (): string => positive ? 'truthy' : 'falsy' };
       common.state = 'should be';
     } else if (fn === 'includes') {
       assertion.operator = fn;
-      [assertion.actual, assertion.expected, assertion.message] = args as [unknown, unknown, string];
+      [assertion.actual, assertion.expected, assertion.message] = castTo(args);
     } else if (fn === 'instanceof') {
       assertion.operator = fn;
-      [assertion.actual, assertion.expected, assertion.message] = args as [unknown, unknown, string];
-      assertion.actual = (assertion.actual as ClassInstance)?.constructor;
+      [assertion.actual, assertion.expected, assertion.message] = castTo(args);
+      assertion.actual = asConstructable(assertion.actual)?.constructor;
     } else { // Handle unknown
       assertion.operator = fn ?? '';
-      [assertion.actual, assertion.expected, assertion.message] = args as [unknown, unknown, string];
+      [assertion.actual, assertion.expected, assertion.message] = castTo(args);
     }
 
     try {
@@ -79,25 +75,25 @@ export class AssertCheck {
         assertion.expected = AssertUtil.cleanValue(assertion.expected);
       }
 
-      const [actual, expected, message] = args as [unknown, unknown, string];
+      const [actual, expected, message]: [unknown, unknown, string] = castTo(args);
 
       // Actually run the assertion
       switch (fn) {
-        case 'includes': assertFn((actual as unknown[]).includes(expected), message); break;
-        case 'test': assertFn((expected as RegExp).test(actual as string), message); break;
-        case 'instanceof': assertFn(actual instanceof (expected as Class), message); break;
-        case 'in': assertFn((actual as string) in (expected as object), message); break;
-        case 'lessThan': assertFn((actual as number) < (expected as number), message); break;
-        case 'lessThanEqual': assertFn((actual as number) <= (expected as number), message); break;
-        case 'greaterThan': assertFn((actual as number) > (expected as number), message); break;
-        case 'greaterThanEqual': assertFn((actual as number) >= (expected as number), message); break;
-        case 'ok': assertFn(...args as [unknown, string]); break;
+        case 'includes': assertFn(castTo<unknown[]>(actual).includes(expected), message); break;
+        case 'test': assertFn(castTo<RegExp>(expected).test(castTo(actual)), message); break;
+        case 'instanceof': assertFn(actual instanceof castTo<Class>(expected), message); break;
+        case 'in': assertFn(castTo<string>(actual) in castTo<object>(expected), message); break;
+        case 'lessThan': assertFn(castTo<number>(actual) < castTo<number>(expected), message); break;
+        case 'lessThanEqual': assertFn(castTo<number>(actual) <= castTo<number>(expected), message); break;
+        case 'greaterThan': assertFn(castTo<number>(actual) > castTo<number>(expected), message); break;
+        case 'greaterThanEqual': assertFn(castTo<number>(actual) >= castTo<number>(expected), message); break;
+        case 'ok': assertFn(...castTo<Parameters<typeof assertFn>>(args)); break;
         default:
-          if (fn && assert[fn as keyof typeof assert]) { // Assert call
+          if (fn && assert[castKey<typeof assert>(fn)]) { // Assert call
             if (/not/i.test(fn)) {
               common.state = 'should not';
             }
-            assert[fn as 'ok'].apply(null, args as [boolean, string | undefined]);
+            assert[castTo<'ok'>(fn)].apply(null, castTo(args));
           }
       }
 
@@ -118,7 +114,6 @@ export class AssertCheck {
       }
       throw err;
     }
-    /* eslint-enable @typescript-eslint/consistent-type-assertions */
   }
 
   /**
@@ -215,8 +210,6 @@ export class AssertCheck {
   ): void {
     let missed: Error | undefined;
 
-    assertion.file = RuntimeIndex.getSourceFile(assertion.file);
-
     try {
       action();
       if (!positive) {
@@ -249,8 +242,6 @@ export class AssertCheck {
   ): Promise<void> {
     let missed: Error | undefined;
 
-    assertion.file = RuntimeIndex.getSourceFile(assertion.file);
-
     try {
       if ('then' in action) {
         await action;
@@ -274,13 +265,13 @@ export class AssertCheck {
    * Look for any unhandled exceptions
    */
   static checkUnhandled(test: TestConfig, err: Error | assert.AssertionError): void {
-    let line = AssertUtil.getPositionOfError(err, test.file).line;
+    let line = AssertUtil.getPositionOfError(err, test.sourceImport ?? test.import).line;
     if (line === 1) {
       line = test.lineStart;
     }
 
     AssertCapture.add({
-      file: test.file,
+      import: test.import,
       line,
       operator: 'throws',
       error: err,

package/src/assert/util.ts

@@ -1,13 +1,13 @@
 import util from 'node:util';
+import path from 'node:path';
 
-import { path, RuntimeIndex, RuntimeContext } from '@travetto/manifest';
+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 } {
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  return !!o && !!(o as { toClean: unknown }).toClean;
+  return !!o && typeof o === 'object' && 'toClean' in o && typeof o.toClean === 'function';
 }
 
 /**
@@ -19,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();
@@ -27,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;
@@ -35,20 +35,22 @@ export class AssertUtil {
         break;
       }
     }
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return util.inspect(val, false, 1).replace(/\n/g, ' ');
   }
 
   /**
    * Determine file location for a given error and the stack trace
    */
-  static getPositionOfError(err: Error, filename: string): { file: string, line: number } {
-    const cwd = RuntimeIndex.mainModule.sourcePath;
-    const lines = path.toPosix(err.stack ?? new Error().stack!)
+  static getPositionOfError(err: Error, imp: string): { import: string, line: number } {
+    const cwd = Runtime.mainSourcePath;
+    const lines = (err.stack ?? new Error().stack!)
+      .replace(/[\\/]/g, '/')
       .split('\n')
       // Exclude node_modules, target self
       .filter(x => x.includes(cwd) && (!x.includes('node_modules') || x.includes('/support/')));
 
+    const filename = RuntimeIndex.getFromImport(imp)?.sourceFile!;
+
     let best = lines.filter(x => x.includes(filename))[0];
 
     if (!best) {
@@ -56,12 +58,12 @@ export class AssertUtil {
     }
 
     if (!best) {
-      return { file: filename, line: 1 };
+      return { import: imp, line: 1 };
     }
 
     const pth = best.trim().split(/\s+/g).slice(1).pop()!;
     if (!pth) {
-      return { file: filename, line: 1 };
+      return { import: imp, line: 1 };
     }
 
     const [file, lineNo] = pth
@@ -78,7 +80,7 @@ export class AssertUtil {
 
     const outFile = outFileParts.length > 1 ? outFileParts[1].replace(/^[\/]/, '') : filename;
 
-    const res = { file: outFile, line };
+    const res = { import: RuntimeIndex.getFromSource(outFile)?.import!, line };
 
     return res;
   }
@@ -86,8 +88,8 @@ 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 } {
-    const { file, ...pos } = this.getPositionOfError(error, suite.file);
+  static generateSuiteFailure(suite: SuiteConfig, methodName: string, error: Error): SuiteFailure {
+    const { import: imp, ...pos } = this.getPositionOfError(error, suite.import);
     let line = pos.line;
 
     if (line === 1 && suite.lineStart) {
@@ -96,7 +98,7 @@ export class AssertUtil {
 
     const msg = error.message.split(/\n/)[0];
 
-    const core = { file, classId: suite.classId, methodName, module: RuntimeContext.main.name };
+    const core = { import: imp, classId: suite.classId, methodName };
     const coreAll = { ...core, description: msg, lineStart: line, lineEnd: line, lineBodyStart: line };
 
     const assert: Assertion = {
@@ -107,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/registry.ts

@@ -1,4 +1,4 @@
-import type { Class, ConcreteClass } from '@travetto/base';
+import { classConstruct, type Class } from '@travetto/runtime';
 import { TestConsumer } from './types';
 
 /**
@@ -45,8 +45,7 @@ class $TestConsumerRegistry {
     await this.manualInit();
 
     return typeof consumer === 'string' ?
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      new ((this.get(consumer) ?? this.#primary) as ConcreteClass)() :
+      classConstruct(this.get(consumer) ?? this.#primary) :
       consumer;
   }
 }

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

@@ -1,22 +1,22 @@
-import { AppError, TypedObject } from '@travetto/base';
+import { AppError, TypedObject } from '@travetto/runtime';
 
 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
    */
-  static serializeError(e: Error | SerializedError): SerializedError;
+  static serializeError(e: Error | SerializedError): Error;
   static serializeError(e: undefined): undefined;
-  static serializeError(e: Error | SerializedError | undefined): SerializedError | undefined {
+  static serializeError(e: Error | SerializedError | undefined): Error | undefined {
     let error: SerializedError | undefined;
 
     if (e) {
@@ -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,27 +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) {
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          out.test.error = this.serializeError(out.test.error) as Error;
-        }
-      } else if (out.type === 'assertion') {
-        if (out.assertion.error) {
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          out.assertion.error = this.serializeError(out.assertion.error) as 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

@@ -1,25 +1,25 @@
 import { existsSync } from 'node:fs';
 
-import { Class } from '@travetto/base';
+import { Class, RuntimeIndex } from '@travetto/runtime';
 
 import { TestConsumer } from '../types';
 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]);
   }
 
   /**
@@ -28,17 +28,10 @@ export class CumulativeSummaryConsumer implements TestConsumer {
    */
   summarizeSuite(test: TestResult): SuiteResult {
     // Was only loading to verify existence (TODO: double-check)
-    if (existsSync(test.file)) {
-      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);
-      }
+    if (existsSync(RuntimeIndex.getFromImport(test.import)!.sourceFile)) {
+      (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);
     }
@@ -50,7 +43,7 @@ export class CumulativeSummaryConsumer implements TestConsumer {
   removeClass(clsId: string): SuiteResult {
     this.#state[clsId] = {};
     return {
-      classId: clsId, passed: 0, failed: 0, skipped: 0, total: 0, tests: [], duration: 0, file: '', lines: { start: 0, end: 0 }
+      classId: clsId, passed: 0, failed: 0, skipped: 0, total: 0, tests: [], duration: 0, import: '', lineStart: 0, lineEnd: 0
     };
   }
 
@@ -70,8 +63,9 @@ export class CumulativeSummaryConsumer implements TestConsumer {
       passed: total.passed,
       failed: total.failed,
       skipped: total.skipped,
-      file: suite.file,
-      lines: suite.lines,
+      import: suite.import,
+      lineStart: suite.lineStart,
+      lineEnd: suite.lineEnd,
       total: total.failed + total.passed,
       tests: [],
       duration: 0
@@ -82,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`);
   }
 }