@travetto/test 5.0.0-rc.8 → 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.8",
+  "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.8",
-    "@travetto/registry": "^5.0.0-rc.8",
-    "@travetto/terminal": "^5.0.0-rc.8",
-    "@travetto/worker": "^5.0.0-rc.8",
-    "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.8",
-    "@travetto/transformer": "^5.0.0-rc.5"
+    "@travetto/cli": "^5.0.0",
+    "@travetto/transformer": "^5.0.0"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/assert/capture.ts

@@ -26,15 +26,15 @@ class $AssertCapture {
 
     // Emit and collect, every assertion as it occurs
     const handler = (a: CaptureAssert): void => {
-      const assrt: Assertion = {
+      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,6 +1,6 @@
 import assert from 'node:assert';
 
-import { AppError, ClassInstance, Class } from '@travetto/runtime';
+import { AppError, Class, castTo, castKey, asConstructable } from '@travetto/runtime';
 
 import { ThrowableError, TestConfig, Assertion } from '../model/test';
 import { AssertCapture, CaptureAssert } from './capture';
@@ -34,36 +34,35 @@ export class AssertCheck {
     // Invert check for negative
     const assertFn = positive ? assert : (x: unknown, msg?: string): unknown => assert(!x, msg);
 
-    /* eslint-disable @typescript-eslint/consistent-type-assertions */
     // 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 {
@@ -76,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));
           }
       }
 
@@ -115,7 +114,6 @@ export class AssertCheck {
       }
       throw err;
     }
-    /* eslint-enable @typescript-eslint/consistent-type-assertions */
   }
 
   /**
@@ -267,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,13 +1,13 @@
 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 } {
-  // 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,7 +35,6 @@ export class AssertUtil {
         break;
       }
     }
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return util.inspect(val, false, 1).replace(/\n/g, ' ');
   }
 
@@ -89,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;
 
@@ -110,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/runtime';
+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}

@@ -5,18 +5,18 @@ 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

@@ -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,16 +29,20 @@ export class TapStreamedEmitter implements TestConsumer {
     this.#consumer.onStart();
 
     let failed = 0;
-    const succ = StyleUtil.getStyle({ text: '#e5e5e5', background: '#026020' }); // White on dark green
+    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(
       Util.mapAsyncItr(
         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 : succ }) })
+        TerminalUtil.progressBarUpdater(this.#terminal, { style: () => ({ complete: failed ? fail : success }) })
       ),
       { minDelay: 100 }
     );

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 });
         }
       }

package/src/decorator/suite.ts

@@ -1,4 +1,4 @@
-import { Class, ClassInstance, describeFunction } from '@travetto/runtime';
+import { castTo, Class, ClassInstance, describeFunction } from '@travetto/runtime';
 
 import { SuiteRegistry } from '../registry/suite';
 import { SuiteConfig } from '../model/suite';
@@ -23,17 +23,16 @@ export function Suite(description?: string | Partial<SuiteConfig>, ...rest: Part
     Object.assign(extra, r);
   }
 
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  const decorator = ((target: Class) => {
+  const dec = (target: Class): typeof target => {
     const cfg = { description: descriptionString, ...extra };
     if (describeFunction(target).abstract) {
       cfg.skip = true;
     }
     SuiteRegistry.register(target, cfg);
     return target;
-  }) as ClassDecorator;
+  };
 
-  return decorator;
+  return castTo(dec);
 }
 
 function listener(phase: SuitePhase) {