@travetto/test 2.1.3 → 2.2.0

package/README.md

@@ -88,12 +88,12 @@ let SimpleTest = class SimpleTest {
         ᚕ_check_1.AssertCheck.check({ file: ᚕsrc(__filename), line: 11, text: "{ size: 20, address: { state: 'VA' } } === {}", operator: "deepStrictEqual" }, true, { size: 20, address: { state: 'VA' } }, {});
     }
 };
-(0, tslib_1.__decorate)([
+tslib_1.__decorate([
     (0, test_1.Test)({ lines: { start: 8, end: 12, codeStart: 11 } })
 ], SimpleTest.prototype, "test", null);
-SimpleTest = (0, tslib_1.__decorate)([
+SimpleTest = tslib_1.__decorate([
     ᚕ_decorator_1.Register(),
-    (0, test_1.Suite)({ lines: { start: 5, end: 13 } })
+    (0, test_1.Suite)({ lines: {} })
 ], SimpleTest);
 Object.defineProperty(exports, 'ᚕtrv', { configurable: true, value: true });
 ```

package/bin/cli-test.ts

@@ -16,27 +16,29 @@ export class TestPlugin extends BasePlugin {
   name = 'test';
   _types: string[];
 
-  getTypes() {
+  getTypes(): string[] {
     if (!this._types) {
       this._types = ScanFs.scanDirSync({},
         PathUtil.resolveUnix(__dirname, '..', 'src/consumer/types/')
       )
-        .filter(x => x.stats.isFile())
-        .map(x => readFileSync(x.file, 'utf8').match(/@Consumable[(]'([^']+)/)?.[1] as string);
+        .filter(x => x.stats?.isFile())
+        .map(x => readFileSync(x.file, 'utf8').match(/@Consumable[(]'([^']+)/)?.[1])
+        .filter((x?: string): x is string => !!x);
     }
     return this._types;
   }
 
+  // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
   getOptions() {
     return {
       format: this.choiceOption({ desc: 'Output format for test results', def: 'tap', choices: this.getTypes() }),
       concurrency: this.intOption({ desc: 'Number of tests to run concurrently', lower: 1, upper: 32, def: Math.min(4, os.cpus().length - 1) }),
       isolated: this.boolOption({ desc: 'Isolated mode' }),
       mode: this.choiceOption({ desc: 'Test run mode', def: 'standard', choices: [...modes] })
-    };
+    } as const;
   }
 
-  envInit() {
+  envInit(): void {
     EnvInit.init({
       debug: '0',
       set: { TRV_LOG_TIME: '0' },
@@ -49,11 +51,11 @@ export class TestPlugin extends BasePlugin {
     });
   }
 
-  getArgs() {
+  getArgs(): string {
     return '[regexes...]';
   }
 
-  async isFile(file: string, errorIfNot?: string) {
+  async isFile(file: string, errorIfNot?: string): Promise<true | undefined> {
     try {
       const stat = await FsUtil.exists(file);
       const res = stat?.isFile();
@@ -67,12 +69,12 @@ export class TestPlugin extends BasePlugin {
     }
   }
 
-  async onSingle(state: Partial<RunState>, file: string) {
+  async onSingle(state: Partial<RunState>, file: string): Promise<void> {
     await this.isFile(file, 'You must specify a proper test file to run in single mode');
     state.mode = 'single';
   }
 
-  async onStandard(state: Partial<RunState>, first: string) {
+  async onStandard(state: Partial<RunState>, first: string): Promise<void> {
     const isFile = await this.isFile(first);
 
     if (!first) {
@@ -95,7 +97,7 @@ export class TestPlugin extends BasePlugin {
 
     const [first] = regexes;
 
-    const state: Partial<RunState> = {
+    const state: RunState = {
       args: regexes,
       mode: this.cmd.mode,
       concurrency: +this.cmd.concurrency,
@@ -108,6 +110,6 @@ export class TestPlugin extends BasePlugin {
       case 'standard': await this.onStandard(state, first); break;
     }
 
-    await runTests(state as RunState);
+    await runTests(state);
   }
 }

package/bin/lib/run.ts

@@ -4,7 +4,7 @@ import type { RunState } from '../../src/execute/types';
  * Run tests given the input state
  * @param opts
  */
-export async function runTests(opts: RunState) {
+export async function runTests(opts: RunState): Promise<void> {
   const { PhaseManager, Util } = await import('@travetto/base');
   await PhaseManager.run('init', '*', ['@trv:registry/init']); // Delay registry
 
@@ -14,6 +14,7 @@ export async function runTests(opts: RunState) {
   RunnerUtil.registerCleanup('runner');
 
   if (process.env.TRV_TEST_DELAY) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     await Util.wait(process.env.TRV_TEST_DELAY as '2s');
   }
 

package/bin/test-child.ts

@@ -3,7 +3,7 @@ import { createWriteStream } from 'fs';
 import { AppCache } from '@travetto/boot';
 import { EnvInit } from '@travetto/base/bin/init';
 
-export async function customLogs() {
+export async function customLogs(): Promise<void> {
   const { ConsoleManager } = await import('@travetto/base');
 
   const c = new console.Console({
@@ -16,7 +16,7 @@ export async function customLogs() {
   });
 }
 
-export async function main() {
+export async function main(): Promise<void> {
   EnvInit.init({
     debug: '0',
     set: { TRV_LOG_TIME: '0' },

package/bin/test-direct.ts

@@ -2,7 +2,7 @@ import { EnvInit } from '@travetto/base/bin/init';
 import { runTests } from './lib/run';
 
 // Direct entry point
-export function main(...args: string[]) {
+export function main(...args: string[]): Promise<void> {
   EnvInit.init({
     debug: '0',
     set: { TRV_LOG_TIME: '0' },

package/bin/test-watch.ts

@@ -1,6 +1,6 @@
 import { EnvInit } from '@travetto/base/bin/init';
 
-export async function main(format: string = 'tap') {
+export async function main(format: string = 'tap'): Promise<void> {
   EnvInit.init({
     debug: '0',
     set: { TRV_LOG_TIME: '0' },

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@travetto/test",
   "displayName": "Testing",
-  "version": "2.1.3",
+  "version": "2.2.0",
   "description": "Declarative test framework",
   "keywords": [
     "unit-testing",
@@ -29,15 +29,15 @@
     "directory": "module/test"
   },
   "dependencies": {
-    "@travetto/base": "^2.1.2",
-    "@travetto/transformer": "^2.1.2",
-    "@travetto/registry": "^2.1.3",
-    "@travetto/watch": "^2.1.2",
-    "@travetto/worker": "^2.1.2",
-    "@travetto/yaml": "^2.1.3"
+    "@travetto/base": "^2.2.0",
+    "@travetto/transformer": "^2.2.0",
+    "@travetto/registry": "^2.2.0",
+    "@travetto/watch": "^2.2.0",
+    "@travetto/worker": "^2.2.0",
+    "@travetto/yaml": "^2.2.0"
   },
   "optionalPeerDependencies": {
-    "@travetto/cli": "^2.1.2"
+    "@travetto/cli": "^2.2.0"
   },
   "publishConfig": {
     "access": "public"

package/src/assert/capture.ts

@@ -20,11 +20,11 @@ class $AssertCapture {
    * @param test Test to capture for
    * @param listener optional listener for events
    */
-  collector(test: TestConfig, listener?: (a: Assertion) => void) {
+  collector(test: TestConfig, listener?: (a: Assertion) => void): () => Assertion[] {
     const assertions: Assertion[] = [];
 
     // Emit and collect, every assertion as it occurs
-    const handler = (a: CaptureAssert) => {
+    const handler = (a: CaptureAssert): void => {
       const assrt = {
         ...a,
         classId: test.classId,
@@ -44,7 +44,7 @@ class $AssertCapture {
     };
   }
 
-  add(a: CaptureAssert) {
+  add(a: CaptureAssert): void {
     this.#emitter.emit('assert', a);
   }
 }

package/src/assert/check.ts

@@ -3,7 +3,7 @@ import * as assert from 'assert';
 import { PathUtil } from '@travetto/boot';
 import { Util, AppError, ClassInstance, Class } from '@travetto/base';
 
-import { ThrowableError, TestConfig } from '../model/test';
+import { ThrowableError, TestConfig, Assertion } from '../model/test';
 import { AssertCapture, CaptureAssert } from './capture';
 import { AssertUtil } from './util';
 import { ASSERT_FN_OPERATOR, OP_MAPPING } from './types';
@@ -14,6 +14,11 @@ declare module 'assert' {
   }
 }
 
+type StringFields<T> = {
+  [K in Extract<keyof T, string>]:
+  (T[K] extends string ? K : never) // eslint-disable-line @typescript-eslint/ban-types
+}[Extract<keyof T, string>];
+
 /**
  * Check assertion
  */
@@ -24,7 +29,7 @@ export class AssertCheck {
    * @param positive Is the check positive or negative
    * @param args The arguments passed in
    */
-  static check(assertion: CaptureAssert, positive: boolean, ...args: unknown[]) {
+  static check(assertion: CaptureAssert, positive: boolean, ...args: unknown[]): void {
     let fn = assertion.operator;
     assertion.operator = ASSERT_FN_OPERATOR[fn];
 
@@ -34,36 +39,45 @@ export class AssertCheck {
     };
 
     // Invert check for negative
-    const assertFn = positive ? assert : (x: unknown, msg?: string) => assert(!x, msg);
+    const assertFn = positive ? assert : (x: unknown, msg?: string): unknown => assert(!x, msg);
 
     // Check fn to call
     if (fn === 'fail') {
       if (args.length > 1) {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         [assertion.actual, assertion.expected, assertion.message, assertion.operator] = args as [unknown, unknown, string, string];
       } else {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         [assertion.message] = args as [string];
       }
     } else if (/throw|reject/i.test(fn)) {
       assertion.operator = fn;
       if (typeof args[1] !== 'string') {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         [, assertion.expected, assertion.message] = args as [unknown, unknown, string];
       } else {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         [, assertion.message] = args as [unknown, string];
       }
     } else if (fn === 'ok' || fn === 'assert') {
       fn = assertion.operator = 'ok';
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       [assertion.actual, assertion.message] = args as [unknown, string];
       assertion.expected = { toClean: () => positive ? 'truthy' : 'falsy' };
       common.state = 'should be';
     } else if (fn === 'includes') {
       assertion.operator = fn;
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       [assertion.expected, assertion.actual, assertion.message] = args as [unknown, unknown, string];
     } else if (fn === 'instanceof') {
       assertion.operator = fn;
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       [assertion.actual, assertion.expected, assertion.message] = args as [unknown, unknown, string];
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       assertion.actual = (assertion.actual as ClassInstance)?.constructor;
     } else { // Handle unknown
       assertion.operator = fn ?? '';
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       [assertion.actual, assertion.expected, assertion.message] = args as [unknown, unknown, string];
     }
 
@@ -77,44 +91,56 @@ export class AssertCheck {
         assertion.expected = AssertUtil.cleanValue(assertion.expected);
       }
 
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       const [actual, expected, message] = args as [unknown, unknown, string];
 
       // Actually run the assertion
       switch (fn) {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         case 'instanceof': assertFn(actual instanceof (expected as Class), message); break;
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         case 'in': assertFn((actual as string) in (expected as object), message); break;
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         case 'lessThan': assertFn((actual as number) < (expected as number), message); break;
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         case 'lessThanEqual': assertFn((actual as number) <= (expected as number), message); break;
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         case 'greaterThan': assertFn((actual as number) > (expected as number), message); break;
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         case 'greaterThanEqual': assertFn((actual as number) >= (expected as number), message); break;
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         case 'ok': assertFn.apply(null, args as [unknown, string]); break; // eslint-disable-line prefer-spread
         default:
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
           if (fn && assert[fn as keyof typeof assert]) { // Assert call
             if (/not/i.test(fn)) {
               common.state = 'should not';
             }
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
             assert[fn as 'ok'].apply(null, args as [boolean, string | undefined]);
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
           } else if (expected && !!(expected as Record<string, Function>)[fn]) { // Dotted Method call (e.g. assert.rejects)
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
             assertFn((expected as typeof assert)[fn as 'ok'](actual));
           }
       }
 
       // Pushing on not error
       AssertCapture.add(assertion);
-    } catch (e) {
+    } catch (err) {
       // On error, produce the appropriate error message
-      if (e instanceof assert.AssertionError) {
+      if (err instanceof assert.AssertionError) {
         if (!assertion.message) {
           assertion.message = (OP_MAPPING[fn] ?? '{state} be {expected}');
         }
         assertion.message = assertion.message
-          .replace(/[{]([A-Za-z]+)[}]/g, (a, k) => common[k] || assertion[k as keyof typeof assertion] as string)
+          .replace(/[{]([A-Za-z]+)[}]/g, (a, k: StringFields<Assertion>) => common[k] || assertion[k]!)
           .replace(/not not/g, ''); // Handle double negatives
-        assertion.error = e;
-        e.message = assertion.message;
+        assertion.error = err;
+        err.message = assertion.message;
         AssertCapture.add(assertion);
       }
-      throw e;
+      throw err;
     }
   }
 
@@ -158,6 +184,30 @@ export class AssertCheck {
     }
   }
 
+  static #onError(
+    positive: boolean,
+    message: string | undefined,
+    err: unknown, missed: Error | undefined,
+    shouldThrow: ThrowableError | undefined,
+    assertion: CaptureAssert
+  ): void {
+    if (Util.isPrimitive(err)) {
+      err = new Error(`${err}`);
+    }
+    if (!(err instanceof Error)) {
+      throw err;
+    }
+    if (positive) {
+      missed = new AppError('Error thrown, but expected no errors', 'general', {}, err.stack);
+    }
+
+    const resolvedErr = (missed && err) ?? this.checkError(shouldThrow, err);
+    if (resolvedErr) {
+      assertion.message = message || missed?.message || resolvedErr.message;
+      throw (assertion.error = resolvedErr);
+    }
+  }
+
   /**
    * Check the throw, doesNotThrow behavior of an assertion
    * @param assertion The basic assertion information
@@ -166,7 +216,13 @@ export class AssertCheck {
    * @param shouldThrow Should this action throw
    * @param message Message to share on failure
    */
-  static checkThrow(assertion: CaptureAssert, positive: boolean, action: Function, shouldThrow?: ThrowableError, message?: string) {
+  static checkThrow(
+    assertion: CaptureAssert,
+    positive: boolean,
+    action: Function,
+    shouldThrow?: ThrowableError,
+    message?: string
+  ): void {
     let missed: Error | undefined;
 
     try {
@@ -177,17 +233,8 @@ export class AssertCheck {
         }
         throw (missed = new AppError(`No error thrown, but expected ${shouldThrow ?? 'an error'}`));
       }
-    } catch (e) {
-      if (positive) {
-        missed = new AppError('Error thrown, but expected no errors');
-        missed.stack = e.stack;
-      }
-
-      e = (missed && e) || this.checkError(shouldThrow, e);
-      if (e) {
-        assertion.message = message || missed?.message || e.message;
-        throw (assertion.error = e);
-      }
+    } catch (err) {
+      this.#onError(positive, message, err, missed, shouldThrow, assertion);
     } finally {
       AssertCapture.add(assertion);
     }
@@ -201,7 +248,13 @@ export class AssertCheck {
    * @param shouldThrow Should this action reject
    * @param message Message to share on failure
    */
-  static async checkThrowAsync(assertion: CaptureAssert, positive: boolean, action: Function | Promise<unknown>, shouldThrow?: ThrowableError, message?: string) {
+  static async checkThrowAsync(
+    assertion: CaptureAssert,
+    positive: boolean,
+    action: Function | Promise<unknown>,
+    shouldThrow?: ThrowableError,
+    message?: string
+  ): Promise<void> {
     let missed: Error | undefined;
 
     try {
@@ -216,16 +269,8 @@ export class AssertCheck {
         }
         throw (missed = new AppError(`No error thrown, but expected ${shouldThrow ?? 'an error'} `));
       }
-    } catch (e) {
-      if (positive) {
-        missed = new AppError('Error thrown, but expected no errors');
-      }
-
-      e = (missed && e) || this.checkError(shouldThrow, e);
-      if (e) {
-        assertion.message = message || missed?.message || e.message;
-        throw (assertion.error = e);
-      }
+    } catch (err) {
+      this.#onError(positive, message, err, missed, shouldThrow, assertion);
     } finally {
       AssertCapture.add(assertion);
     }
@@ -234,7 +279,7 @@ export class AssertCheck {
   /**
    * Look for any unhandled exceptions
    */
-  static checkUnhandled(test: TestConfig, err: Error | assert.AssertionError) {
+  static checkUnhandled(test: TestConfig, err: Error | assert.AssertionError): void {
     let line = AssertUtil.getPositionOfError(err, test.file).line;
     if (line === 1) {
       line = test.lines.start;

package/src/assert/util.ts

@@ -7,6 +7,7 @@ import { TestConfig, Assertion, TestResult } from '../model/test';
 import { SuiteConfig } 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;
 }
 
@@ -17,7 +18,7 @@ export class AssertUtil {
   /**
    * Clean a value for displaying in the output
    */
-  static cleanValue(val: unknown) {
+  static cleanValue(val: unknown): unknown {
     if (isCleanable(val)) {
       return val.toClean();
     } else if (val === null || val === undefined
@@ -26,6 +27,7 @@ export class AssertUtil {
     ) {
       return JSON.stringify(val);
     } else {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       const subV = val as (Class | ClassInstance);
       if (subV.ᚕid || !subV.constructor || (!subV.constructor.ᚕid && Util.isFunction(subV))) { // If a function, show name
         return subV.name;
@@ -38,7 +40,7 @@ export class AssertUtil {
   /**
    * Determine file location for a given error and the stack trace
    */
-  static getPositionOfError(err: Error, filename: string) {
+  static getPositionOfError(err: Error, filename: string): { file: string, line: number } {
     const lines = (err.stack ?? new Error().stack!)
       .replace(/[\\]/g, '/')
       .split('\n')
@@ -82,7 +84,7 @@ export class AssertUtil {
   /**
    * Generate a suite error given a suite config, and an error
    */
-  static generateSuiteError(suite: SuiteConfig, methodName: string, error: Error) {
+  static generateSuiteError(suite: SuiteConfig, methodName: string, error: Error): { assert: Assertion, testResult: TestResult, testConfig: TestConfig } {
     const { file, ...pos } = this.getPositionOfError(error, suite.file);
     let line = pos.line;
 

package/src/consumer/enhancer.ts

@@ -20,5 +20,8 @@ export type TestResultsEnhancer = typeof COLOR_ENHANCER;
 /**
  * Dummy enhancer does nothing
  */
-export const DUMMY_ENHANCER = (Object.keys(COLOR_ENHANCER) as (keyof typeof COLOR_ENHANCER)[])
-  .reduce((acc, k) => (acc[k] = (x: unknown) => `${x}`) && acc, {} as TestResultsEnhancer);
+export const DUMMY_ENHANCER: TestResultsEnhancer = [
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  (Object.keys(COLOR_ENHANCER) as (keyof typeof COLOR_ENHANCER)[])
+    .reduce<Partial<TestResultsEnhancer>>((acc, k) => (acc[k] = (x: unknown): string => `${x}`) && acc, {})
+].filter((x): x is TestResultsEnhancer => !!x)[0];

package/src/consumer/registry.ts

@@ -9,9 +9,9 @@ class $TestConsumerRegistry {
   #primary: Class<TestConsumer>;
 
   /**
-   * Manual initialization when running oustide of the bootstrap process
+   * Manual initialization when running outside of the bootstrap process
    */
-  async manualInit() {
+  async manualInit(): Promise<void> {
     await import('./types/index');
   }
 
@@ -21,7 +21,7 @@ class $TestConsumerRegistry {
    * @param cls The consumer class
    * @param isDefault Set as the default consumer
    */
-  add(type: string, cls: Class<TestConsumer>, isDefault = false) {
+  add(type: string, cls: Class<TestConsumer>, isDefault = false): void {
     if (isDefault) {
       this.#primary = cls;
     }
@@ -32,8 +32,8 @@ class $TestConsumerRegistry {
    * Retrieve a registered consumer
    * @param type The unique identifier
    */
-  get(type: string) {
-    return this.#registered.get(type);
+  get(type: string): Class<TestConsumer> {
+    return this.#registered.get(type)!;
   }
 
   /**
@@ -42,6 +42,7 @@ class $TestConsumerRegistry {
    */
   getInstance(consumer: string | TestConsumer): TestConsumer {
     return typeof consumer === 'string' ?
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       new ((this.get(consumer) ?? this.#primary) as ConcreteClass)() :
       consumer;
   }
@@ -54,8 +55,9 @@ export const TestConsumerRegistry = new $TestConsumerRegistry();
  * @param type The unique identifier for the consumer
  * @param isDefault Is this the default consumer.  Last one wins
  */
-export function Consumable(type: string, isDefault = false) {
+export function Consumable(type: string, isDefault = false): ClassDecorator {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return function (cls: Class<TestConsumer>) {
     TestConsumerRegistry.add(type, cls, isDefault);
-  };
+  } as ClassDecorator;
 }

package/src/consumer/types/cumulative.ts

@@ -26,7 +26,7 @@ export class CumulativeSummaryConsumer implements TestConsumer {
    */
   summarizeSuite(test: TestResult): SuiteResult {
     try {
-      // TODO: Load asyncronously
+      // TODO: Load asynchronously
       require(test.file);
       this.#state[test.classId] = this.#state[test.classId] ?? {};
       this.#state[test.classId][test.methodName] = test.status;
@@ -42,7 +42,7 @@ export class CumulativeSummaryConsumer implements TestConsumer {
   /**
    * Remove a class
    */
-  removeClass(clsId: string) {
+  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 }
@@ -52,7 +52,7 @@ export class CumulativeSummaryConsumer implements TestConsumer {
   /**
    * Compute totals
    */
-  computeTotal(cls: Class) {
+  computeTotal(cls: Class): SuiteResult {
     const suite = SuiteRegistry.get(cls);
     const total = suite.tests.reduce((acc, x) => {
       const status = this.#state[x.classId][x.methodName] ?? 'unknown';
@@ -77,7 +77,7 @@ 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) {
+  onEvent(e: TestEvent): void {
     this.#target.onEvent(e);
     try {
       if (e.type === 'test' && e.phase === 'after') {

package/src/consumer/types/event.ts

@@ -6,7 +6,7 @@ import { ConsumerUtil } from '../util';
 import { Consumable } from '../registry';
 
 /**
- * Streams all test events a JSON payload, in an ndjson format
+ * Streams all test events a JSON payload, in an nd-json format
  */
 @Consumable('event')
 export class EventStreamer implements TestConsumer {
@@ -16,7 +16,7 @@ export class EventStreamer implements TestConsumer {
     this.#stream = stream;
   }
 
-  onEvent(event: TestEvent) {
+  onEvent(event: TestEvent): void {
     const out = { ...event };
     ConsumerUtil.serializeErrors(out);
     this.#stream.write(`${JSON.stringify(out)}\n`);

package/src/consumer/types/execution.ts

@@ -11,7 +11,7 @@ import { Consumable } from '../registry';
 @Consumable('exec')
 export class ExecutionEmitter extends ChildCommChannel<TestEvent> implements TestConsumer {
 
-  onEvent(event: TestEvent) {
+  onEvent(event: TestEvent): void {
     const out = { ...event };
     ConsumerUtil.serializeErrors(out);
     this.send(event.type, out);

package/src/consumer/types/json.ts

@@ -16,9 +16,9 @@ export class JSONEmitter implements TestConsumer {
     this.#stream = stream;
   }
 
-  onEvent(event: TestEvent) { }
+  onEvent(event: TestEvent): void { }
 
-  onSummary(summary: SuitesSummary) {
+  onSummary(summary: SuitesSummary): void {
     this.#stream.write(JSON.stringify(summary, undefined, 2));
   }
 }