@travetto/test 7.0.0-rc.0 → 7.0.0-rc.2

package/README.md

@@ -21,7 +21,7 @@ This module provides unit testing functionality that integrates with the framewo
 **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#L23) 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#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#L25) decorator.  All tests intrinsically support `async`/`await`. 
 
 A simple example would be:
 
@@ -35,14 +35,14 @@ import { Suite, Test } from '@travetto/test';
 class SimpleTest {
 
   #complexService: {
-    doLongOp(): Promise<number>;
+    doLongOperation(): Promise<number>;
     getText(): string;
   };
 
   @Test()
   async test1() {
-    const val = await this.#complexService.doLongOp();
-    assert(val === 5);
+    const value = await this.#complexService.doLongOperation();
+    assert(value === 5);
   }
 
   @Test()
@@ -212,8 +212,8 @@ class SimpleTest {
 
     await assert.rejects(() => {
       throw new Error('Big Error');
-    }, (err: Error) =>
-      err.message.startsWith('Big') && err.message.length > 4
+    }, (error: Error) =>
+      error.message.startsWith('Big') && error.message.length > 4
     );
   }
 }

package/package.json

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

package/src/assert/check.ts

@@ -13,7 +13,7 @@ type StringFields<T> = {
   (T[K] extends string ? K : never)
 }[Extract<keyof T, string>];
 
-const isClass = (e: unknown): e is Class => e === Error || e === AppError || Object.getPrototypeOf(e) !== Object.getPrototypeOf(Function);
+const isClass = (input: unknown): input is Class => input === Error || input === AppError || Object.getPrototypeOf(input) !== Object.getPrototypeOf(Function);
 
 /**
  * Check assertion
@@ -35,7 +35,7 @@ export class AssertCheck {
     };
 
     // Invert check for negative
-    const assertFn = positive ? assert : (x: unknown, msg?: string): unknown => assert(!x, msg);
+    const assertFn = positive ? assert : (value: unknown, msg?: string): unknown => assert(!value, msg);
 
     // Check fn to call
     if (fn === 'fail') {
@@ -102,36 +102,36 @@ export class AssertCheck {
 
       // Pushing on not error
       AssertCapture.add(assertion);
-    } catch (err) {
+    } catch (error) {
       // On error, produce the appropriate error message
-      if (err instanceof assert.AssertionError) {
+      if (error 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: StringFields<Assertion>) => common[k] || assertion[k]!)
+          .replace(/[{]([A-Za-z]+)[}]/g, (a, key: StringFields<Assertion>) => common[key] || assertion[key]!)
           .replace(/not not/g, ''); // Handle double negatives
-        assertion.error = err;
-        err.message = assertion.message;
+        assertion.error = error;
+        error.message = assertion.message;
         AssertCapture.add(assertion);
       }
-      throw err;
+      throw error;
     }
   }
 
   /**
    * Check a given error
    * @param shouldThrow  Should the test throw anything
-   * @param err The provided error
+   * @param error The provided error
    */
-  static checkError(shouldThrow: ThrowableError | undefined, err: Error | string | undefined): Error | undefined {
+  static checkError(shouldThrow: ThrowableError | undefined, error: Error | string | undefined): Error | undefined {
     if (!shouldThrow) { // If we shouldn't be throwing anything, we are good
       return;
-    } else if (!err) {
+    } else if (!error) {
       return new assert.AssertionError({ message: 'Expected to throw an error, but got nothing' });
     } else if (typeof shouldThrow === 'string') {
-      if (!(err instanceof Error ? err.message : err).includes(shouldThrow)) {
-        const actual = err instanceof Error ? `'${err.message}'` : `'${err}'`;
+      if (!(error instanceof Error ? error.message : error).includes(shouldThrow)) {
+        const actual = error instanceof Error ? `'${error.message}'` : `'${error}'`;
         return new assert.AssertionError({
           message: `Expected error containing text '${shouldThrow}', but got ${actual}`,
           actual,
@@ -139,8 +139,8 @@ export class AssertCheck {
         });
       }
     } else if (shouldThrow instanceof RegExp) {
-      if (!shouldThrow.test(typeof err === 'string' ? err : err.message)) {
-        const actual = err instanceof Error ? `'${err.message}'` : `'${err}'`;
+      if (!shouldThrow.test(typeof error === 'string' ? error : error.message)) {
+        const actual = error instanceof Error ? `'${error.message}'` : `'${error}'`;
         return new assert.AssertionError({
           message: `Expected error with message matching '${shouldThrow.source}', but got ${actual}`,
           actual,
@@ -148,27 +148,27 @@ export class AssertCheck {
         });
       }
     } else if (isClass(shouldThrow)) {
-      if (!(err instanceof shouldThrow)) {
+      if (!(error instanceof shouldThrow)) {
         return new assert.AssertionError({
-          message: `Expected to throw ${shouldThrow.name}, but got ${err}`,
-          actual: (err ?? 'nothing'),
+          message: `Expected to throw ${shouldThrow.name}, but got ${error}`,
+          actual: (error ?? 'nothing'),
           expected: shouldThrow.name
         });
       }
     } else if (typeof shouldThrow === 'function') {
       const target = shouldThrow.name ? `("${shouldThrow.name}")` : '';
       try {
-        const res = shouldThrow(err);
-        if (res === false) {
-          return new assert.AssertionError({ message: `Checking function ${target} indicated an invalid error`, actual: err });
-        } else if (typeof res === 'string') {
-          return new assert.AssertionError({ message: res, actual: err });
+        const result = shouldThrow(error);
+        if (result === false) {
+          return new assert.AssertionError({ message: `Checking function ${target} indicated an invalid error`, actual: error });
+        } else if (typeof result === 'string') {
+          return new assert.AssertionError({ message: result, actual: error });
         }
-      } catch (checkErr) {
-        if (checkErr instanceof assert.AssertionError) {
-          return checkErr;
+      } catch (checkError) {
+        if (checkError instanceof assert.AssertionError) {
+          return checkError;
         } else {
-          return new assert.AssertionError({ message: `Checking function ${target} threw an error`, actual: checkErr });
+          return new assert.AssertionError({ message: `Checking function ${target} threw an error`, actual: checkError });
         }
       }
     }
@@ -177,26 +177,26 @@ export class AssertCheck {
   static #onError(
     positive: boolean,
     message: string | undefined,
-    err: unknown,
+    error: unknown,
     missed: Error | undefined,
     shouldThrow: ThrowableError | undefined,
     assertion: CaptureAssert
   ): void {
-    if (!(err instanceof Error)) {
-      err = new Error(`${err}`);
+    if (!(error instanceof Error)) {
+      error = new Error(`${error}`);
     }
-    if (!(err instanceof Error)) {
-      throw err;
+    if (!(error instanceof Error)) {
+      throw error;
     }
     if (positive) {
       missed = new assert.AssertionError({ message: 'Error thrown, but expected no errors' });
-      missed.stack = err.stack;
+      missed.stack = error.stack;
     }
 
-    const resolvedErr = (missed && err) ?? this.checkError(shouldThrow, err);
-    if (resolvedErr) {
-      assertion.message = message || missed?.message || resolvedErr.message;
-      throw (assertion.error = resolvedErr);
+    const resolvedError = (missed && error) ?? this.checkError(shouldThrow, error);
+    if (resolvedError) {
+      assertion.message = message || missed?.message || resolvedError.message;
+      throw (assertion.error = resolvedError);
     }
   }
 
@@ -225,8 +225,8 @@ export class AssertCheck {
         }
         throw (missed = new assert.AssertionError({ message: `No error thrown, but expected ${shouldThrow ?? 'an error'}`, expected: shouldThrow ?? 'an error' }));
       }
-    } catch (err) {
-      this.#onError(positive, message, err, missed, shouldThrow, assertion);
+    } catch (error) {
+      this.#onError(positive, message, error, missed, shouldThrow, assertion);
     } finally {
       AssertCapture.add(assertion);
     }
@@ -261,8 +261,8 @@ export class AssertCheck {
         }
         throw (missed = new assert.AssertionError({ message: `No error thrown, but expected ${shouldThrow ?? 'an error'}`, expected: shouldThrow ?? 'an error' }));
       }
-    } catch (err) {
-      this.#onError(positive, message, err, missed, shouldThrow, assertion);
+    } catch (error) {
+      this.#onError(positive, message, error, missed, shouldThrow, assertion);
     } finally {
       AssertCapture.add(assertion);
     }
@@ -271,8 +271,8 @@ export class AssertCheck {
   /**
    * Look for any unhandled exceptions
    */
-  static checkUnhandled(test: TestConfig, err: Error | assert.AssertionError): void {
-    let line = AssertUtil.getPositionOfError(err, test.sourceImport ?? test.import).line;
+  static checkUnhandled(test: TestConfig, error: Error | assert.AssertionError): void {
+    let line = AssertUtil.getPositionOfError(error, test.sourceImport ?? test.import).line;
     if (line === 1) {
       line = test.lineStart;
     }
@@ -281,9 +281,9 @@ export class AssertCheck {
       import: test.import,
       line,
       operator: 'throws',
-      error: err,
-      message: err.message,
-      text: ('operator' in err ? err.operator : '') || '(uncaught)'
+      error,
+      message: error.message,
+      text: ('operator' in error ? error.operator : '') || '(uncaught)'
     });
   }
 }

package/src/assert/util.ts

@@ -15,53 +15,53 @@ export class AssertUtil {
   /**
    * Clean a value for displaying in the output
    */
-  static cleanValue(val: unknown): unknown {
-    switch (typeof val) {
-      case 'number': case 'boolean': case 'bigint': case 'string': case 'undefined': return val;
+  static cleanValue(value: unknown): unknown {
+    switch (typeof value) {
+      case 'number': case 'boolean': case 'bigint': case 'string': case 'undefined': return value;
       case 'object': {
-        if (isCleanable(val)) {
-          return val.toClean();
-        } else if (val === null || val.constructor === Object || Array.isArray(val) || val instanceof Date) {
-          return JSON.stringify(val);
+        if (isCleanable(value)) {
+          return value.toClean();
+        } else if (value === null || value.constructor === Object || Array.isArray(value) || value instanceof Date) {
+          return JSON.stringify(value);
         }
         break;
       }
       case 'function': {
-        if (val.Ⲑid || !val.constructor) {
-          return val.name;
+        if (value.Ⲑid || !value.constructor) {
+          return value.name;
         }
         break;
       }
     }
-    return util.inspect(val, false, 1).replace(/\n/g, ' ');
+    return util.inspect(value, false, 1).replace(/\n/g, ' ');
   }
 
   /**
    * Determine file location for a given error and the stack trace
    */
-  static getPositionOfError(err: Error, imp: string): { import: string, line: number } {
-    const cwd = Runtime.mainSourcePath;
-    const lines = (err.stack ?? new Error().stack!)
+  static getPositionOfError(error: Error, importLocation: string): { import: string, line: number } {
+    const workingDirectory = Runtime.mainSourcePath;
+    const lines = (error.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/')));
+      .filter(lineText => lineText.includes(workingDirectory) && (!lineText.includes('node_modules') || lineText.includes('/support/')));
 
-    const filename = RuntimeIndex.getFromImport(imp)?.sourceFile!;
+    const filename = RuntimeIndex.getFromImport(importLocation)?.sourceFile!;
 
-    let best = lines.filter(x => x.includes(filename))[0];
+    let best = lines.filter(lineText => lineText.includes(filename))[0];
 
     if (!best) {
-      [best] = lines.filter(x => x.includes(`${cwd}/test`));
+      [best] = lines.filter(lineText => lineText.includes(`${workingDirectory}/test`));
     }
 
     if (!best) {
-      return { import: imp, line: 1 };
+      return { import: importLocation, line: 1 };
     }
 
     const pth = best.trim().split(/\s+/g).slice(1).pop()!;
     if (!pth) {
-      return { import: imp, line: 1 };
+      return { import: importLocation, line: 1 };
     }
 
     const [file, lineNo] = pth
@@ -74,21 +74,21 @@ export class AssertUtil {
       line = -1;
     }
 
-    const outFileParts = file.split(cwd.replace(/^[A-Za-z]:/, ''));
+    const outFileParts = file.split(workingDirectory.replace(/^[A-Za-z]:/, ''));
 
     const outFile = outFileParts.length > 1 ? outFileParts[1].replace(/^[\/]/, '') : filename;
 
-    const res = { import: RuntimeIndex.getFromSource(outFile)?.import!, line };
+    const result = { import: RuntimeIndex.getFromSource(outFile)?.import!, line };
 
-    return res;
+    return result;
   }
 
   /**
    * Generate a suite error given a suite config, and an error
    */
   static generateSuiteFailure(suite: SuiteConfig, methodName: string, error: Error): SuiteFailure {
-    const { import: imp, ...pos } = this.getPositionOfError(error, suite.import);
-    let line = pos.line;
+    const { import: imp, ...rest } = this.getPositionOfError(error, suite.import);
+    let line = rest.line;
 
     if (line === 1 && suite.lineStart) {
       line = suite.lineStart;
@@ -118,13 +118,13 @@ export class AssertUtil {
   /**
    * 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}`;
+  static gernerateImportFailure(importLocation: string, error: Error): SuiteFailure {
+    const name = path.basename(importLocation);
+    const classId = `${RuntimeIndex.getFromImport(importLocation)?.id}#${name}`;
     const suite = asFull<SuiteConfig & SuiteResult>({
-      class: asFull<Class>({ name }), classId, duration: 0, lineStart: 1, lineEnd: 1, import: imp
+      class: asFull<Class>({ name }), classId, duration: 0, lineStart: 1, lineEnd: 1, import: importLocation
     });
-    err.message = err.message.replaceAll(Runtime.mainSourcePath, '.');
-    return this.generateSuiteFailure(suite, 'require', err);
+    error.message = error.message.replaceAll(Runtime.mainSourcePath, '.');
+    return this.generateSuiteFailure(suite, 'require', error);
   }
 }

package/src/consumer/registry-index.ts

@@ -39,11 +39,11 @@ export class TestConsumerRegistryIndex implements RegistryIndex {
    */
   async #init(): Promise<void> {
     const allFiles = RuntimeIndex.find({
-      module: m => m.name === '@travetto/test',
-      file: f => f.relativeFile.startsWith('src/consumer/types/')
+      module: mod => mod.name === '@travetto/test',
+      file: file => file.relativeFile.startsWith('src/consumer/types/')
     });
-    for (const f of allFiles) {
-      await import(f.outputFile);
+    for (const file of allFiles) {
+      await import(file.outputFile);
     }
     for (const cls of this.store.getClasses()) {
       this.store.finalize(cls);

package/src/consumer/types/cumulative.ts

@@ -30,7 +30,7 @@ export class CumulativeSummaryConsumer extends DelegatingConsumer {
     // Was only loading to verify existence (TODO: double-check)
     if (existsSync(RuntimeIndex.getFromImport(test.import)!.sourceFile)) {
       (this.#state[test.classId] ??= {})[test.methodName] = test.status;
-      const SuiteCls = SuiteRegistryIndex.getClasses().find(x => x.Ⲑid === test.classId);
+      const SuiteCls = SuiteRegistryIndex.getClasses().find(cls => cls.Ⲑid === test.classId);
       return SuiteCls ? this.computeTotal(SuiteCls) : this.removeClass(test.classId);
     } else {
       return this.removeClass(test.classId);
@@ -52,10 +52,10 @@ export class CumulativeSummaryConsumer extends DelegatingConsumer {
    */
   computeTotal(cls: Class): SuiteResult {
     const suite = SuiteRegistryIndex.getConfig(cls);
-    const total = Object.values(suite.tests).reduce((acc, x) => {
-      const status = this.#state[x.classId][x.methodName] ?? 'unknown';
-      acc[status] += 1;
-      return acc;
+    const total = Object.values(suite.tests).reduce((map, config) => {
+      const status = this.#state[config.classId][config.methodName] ?? 'unknown';
+      map[status] += 1;
+      return map;
     }, { skipped: 0, passed: 0, failed: 0, unknown: 0 });
 
     return {
@@ -76,17 +76,17 @@ export class CumulativeSummaryConsumer extends DelegatingConsumer {
    * Listen for event, process the full event, and if the event is an after test,
    * send a full suite summary
    */
-  onEventDone(e: TestEvent): void {
+  onEventDone(event: TestEvent): void {
     try {
-      if (e.type === 'test' && e.phase === 'after') {
+      if (event.type === 'test' && event.phase === 'after') {
         this.onEvent({
           type: 'suite',
           phase: 'after',
-          suite: this.summarizeSuite(e.test),
+          suite: this.summarizeSuite(event.test),
         });
       }
-    } catch (err) {
-      console.warn('Summarization Error', { error: err });
+    } catch (error) {
+      console.warn('Summarization Error', { error });
     }
   }
 }

package/src/consumer/types/delegating.ts

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

package/src/consumer/types/runnable.ts

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

package/src/consumer/types/summarizer.ts

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

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

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