@travetto/test 7.0.0-rc.1 → 7.0.0-rc.3

package/src/worker/standard.ts

@@ -1,26 +1,26 @@
 import { fork } from 'node:child_process';
 
-import { Env, RuntimeIndex, Util } from '@travetto/runtime';
+import { Env, RuntimeIndex } from '@travetto/runtime';
 import { IpcChannel } from '@travetto/worker';
 
-import { Events, TestLogEvent } from './types.ts';
-import { TestConsumerShape } from '../consumer/types.ts';
-import { TestEvent } from '../model/event.ts';
-import { TestRun } from '../model/test.ts';
+import { TestWorkerEvents, type TestLogEvent } from './types.ts';
+import type { TestConsumerShape } from '../consumer/types.ts';
+import type { TestEvent, TestRemoveEvent } from '../model/event.ts';
+import type { TestDiffInput, TestRun } from '../model/test.ts';
+import { CommunicationUtil } from '../communication.ts';
 
-const log = (message: string): void => {
-  process.send?.({ type: 'log', message } satisfies TestLogEvent);
+const log = (message: string | TestLogEvent): void => {
+  const event: TestLogEvent = typeof message === 'string' ? { type: 'log', message } : message;
+  process.send ? process.send?.(event) : console.debug(event.message);
 };
 
 /**
  *  Produce a handler for the child worker
  */
-export async function buildStandardTestManager(consumer: TestConsumerShape, run: TestRun): Promise<void> {
+export async function buildStandardTestManager(consumer: TestConsumerShape, run: TestRun | TestDiffInput): Promise<void> {
   log(`Worker Input ${JSON.stringify(run)}`);
-  log(`Worker Executing ${run.import}`);
 
-  const { module } = RuntimeIndex.getFromImport(run.import)!;
-  const suiteMod = RuntimeIndex.getModule(module)!;
+  const suiteMod = RuntimeIndex.findModuleForArbitraryImport(run.import)!;
 
   const channel = new IpcChannel<TestEvent & { error?: Error }>(
     fork(
@@ -37,25 +37,34 @@ export async function buildStandardTestManager(consumer: TestConsumerShape, run:
     )
   );
 
-  await channel.once(Events.READY); // Wait for the child to be ready
-  await channel.send(Events.INIT); // Initialize
-  await channel.once(Events.INIT_COMPLETE); // Wait for complete
+  await channel.once(TestWorkerEvents.READY); // Wait for the child to be ready
+  await channel.send(TestWorkerEvents.INIT); // Initialize
+  await channel.once(TestWorkerEvents.INIT_COMPLETE); // Wait for complete
 
-  channel.on('*', async ev => {
+  channel.on('*', async event => {
     try {
-      await consumer.onEvent(Util.deserializeFromJson(JSON.stringify(ev)));  // Connect the consumer with the event stream from the child
+      const parsed: TestEvent | TestRemoveEvent | TestLogEvent = CommunicationUtil.deserializeFromObject(event);
+      if (parsed.type === 'log') {
+        log(parsed);
+      } else if (parsed.type === 'removeTest') {
+        log(`Received remove event ${JSON.stringify(event)}@${consumer.constructor.name}`);
+        await consumer.onRemoveEvent?.(parsed); // Forward remove events
+      } else {
+        await consumer.onEvent(parsed);  // Forward standard events
+      }
     } catch {
       // Do nothing
     }
   });
 
   // Listen for child to complete
-  const complete = channel.once(Events.RUN_COMPLETE);
+  const complete = channel.once(TestWorkerEvents.RUN_COMPLETE);
   // Start test
-  channel.send(Events.RUN, run);
+  channel.send(TestWorkerEvents.RUN, run);
 
   // Wait for complete
-  const result = await complete.then(ev => Util.deserializeFromJson<typeof ev>(JSON.stringify(ev)));
+  const completedEvent = await complete;
+  const result: { error?: unknown } = await CommunicationUtil.deserializeFromObject(completedEvent);
 
   // Kill on complete
   await channel.destroy();

package/src/worker/types.ts

@@ -1,10 +1,9 @@
-import { TestEvent } from '../model/event.ts';
-import { TestRun } from '../model/test.ts';
+import { TestEvent, TestRemoveEvent } from '../model/event.ts';
 
 /**
  * Test Run Event Keys
  */
-export const Events = {
+export const TestWorkerEvents = {
   RUN: 'run',
   RUN_COMPLETE: 'runComplete',
   INIT: 'init',
@@ -12,12 +11,17 @@ export const Events = {
   READY: 'ready'
 };
 
-export type TestRemovedEvent = { type: 'removeTest', method?: string } & TestRun;
+export type TestRunEvent = { type: 'runTest', import: string };
+
+export const isTestRunEvent = (event: unknown): event is TestRunEvent =>
+  typeof event === 'object' && !!event && 'type' in event && event.type === 'runTest';
+
+
 export type TestReadyEvent = { type: 'ready' };
 export type TestLogEvent = { type: 'log', message: string };
 
 export type TestWatchEvent =
   TestEvent |
-  TestRemovedEvent |
+  TestRemoveEvent |
   TestReadyEvent |
   TestLogEvent;

package/support/bin/run.ts

@@ -2,23 +2,23 @@ import { getClass, Runtime } from '@travetto/runtime';
 import { SchemaRegistryIndex } from '@travetto/schema';
 
 import { TestConsumerRegistryIndex } from '../../src/consumer/registry-index.ts';
-import type { RunState } from '../../src/execute/types.ts';
+import type { TestConsumerConfig } from '../../src/execute/types.ts';
+import type { TestRunInput } from '../../src/model/test.ts';
 
 /**
  * Run tests given the input state
- * @param opts
+ * @param state
  */
-export async function runTests(opts: RunState): Promise<void> {
-  const { RunnerUtil } = await import('../../src/execute/util.ts');
-  const { Runner } = await import('../../src/execute/runner.ts');
+export async function runTests(state: TestConsumerConfig, input: TestRunInput): Promise<void> {
+  const { RunUtil } = await import('../../src/execute/run.ts');
 
-  RunnerUtil.registerCleanup('runner');
+  RunUtil.registerCleanup('runner');
 
   try {
-    const res = await new Runner(opts).run();
-    process.exitCode = res ? 0 : 1;
-  } catch (err) {
-    console.error('Test Worker Failed', { error: err });
+    const result = await RunUtil.runTests(state, input);
+    process.exitCode = result ? 0 : 1;
+  } catch (error) {
+    console.error('Test Worker Failed', { error });
     process.exitCode = 1;
   }
 }

package/support/cli.test.ts

@@ -1,9 +1,7 @@
 import { EventEmitter } from 'node:events';
-import fs from 'node:fs/promises';
-import path from 'node:path';
 
-import { Env } from '@travetto/runtime';
-import { CliCommandShape, CliCommand, CliValidationError } from '@travetto/cli';
+import { Env, RuntimeIndex } from '@travetto/runtime';
+import { CliCommandShape, CliCommand, CliUtil } from '@travetto/cli';
 import { WorkPool } from '@travetto/worker';
 import { Max, Min } from '@travetto/schema';
 
@@ -20,11 +18,8 @@ export class TestCommand implements CliCommandShape {
   @Min(1) @Max(WorkPool.MAX_SIZE)
   concurrency: number = WorkPool.DEFAULT_SIZE;
 
-  /** Test run mode */
-  mode: 'single' | 'standard' = 'standard';
-
   /**
-   * Tags to target or exclude
+   * Tags to target or exclude when using globs
    * @alias env.TRV_TEST_TAGS
    */
   tags?: string[];
@@ -44,46 +39,30 @@ export class TestCommand implements CliCommandShape {
     Env.TRV_LOG_TIME.clear();
   }
 
-  isFirstFile(first: string): Promise<boolean> {
-    return fs.stat(path.resolve(first ?? '')).then(x => x.isFile(), () => false);
-  }
-
-  async resolvedMode(first: string, rest: string[]): Promise<string> {
-    return (await this.isFirstFile(first)) && rest.length === 0 ? 'single' : this.mode;
-  }
-
   async preValidate(): Promise<void> {
     const { selectConsumer } = await import('./bin/run.ts');
     await selectConsumer(this);
   }
 
-  async validate(first: string = '**/*', rest: string[]): Promise<CliValidationError | undefined> {
-    const mode = await this.resolvedMode(first, rest);
-
-    if (mode === 'single' && !await this.isFirstFile(first)) {
-      return { message: 'You must specify a proper test file to run in single mode', source: 'arg' };
-    }
-  }
-
   async main(first: string = '**/*', globs: string[] = []): Promise<void> {
     const { runTests } = await import('./bin/run.ts');
 
-    const isFirst = await this.isFirstFile(first);
-    const isSingle = this.mode === 'single' || (isFirst && globs.length === 0);
-    const options = Object.fromEntries((this.formatOptions ?? [])?.map(f => [...f.split(':'), true]));
-
-    return runTests({
-      concurrency: this.concurrency,
-      consumer: this.format,
-      consumerOptions: options,
-      tags: this.tags,
-      target: isSingle ?
-        {
-          import: first,
-          classId: globs[0],
-          methodNames: globs.slice(1),
-        } :
-        { globs: [first, ...globs], }
-    });
+    const importPath = RuntimeIndex.getFromImportOrSource(first)?.import;
+
+    return runTests(
+      {
+        concurrency: this.concurrency,
+        consumer: this.format,
+        consumerOptions: CliUtil.readExtendedOptions(this.formatOptions),
+      },
+      importPath ? {
+        import: importPath,
+        classId: globs[0],
+        methodNames: globs.slice(1),
+      } : {
+        globs: [first, ...globs],
+        tags: this.tags,
+      }
+    );
   }
 }

package/support/cli.test_diff.ts

@@ -0,0 +1,47 @@
+import { Env, JSONUtil, RuntimeIndex } from '@travetto/runtime';
+import { CliCommand, CliUtil } from '@travetto/cli';
+import { IsPrivate } from '@travetto/schema';
+
+import { runTests, selectConsumer } from './bin/run.ts';
+import type { TestDiffSource } from '../src/model/test.ts';
+
+/**  Direct test invocation */
+@CliCommand()
+@IsPrivate()
+export class TestDiffCommand {
+
+  format: string = 'tap';
+
+  /**
+   * Format options
+   * @alias o
+   */
+  formatOptions?: string[];
+
+  async preValidate(): Promise<void> {
+    await selectConsumer(this);
+  }
+
+  preMain(): void {
+    Env.TRV_ROLE.set('test');
+    Env.TRV_ENV.set('test');
+    Env.TRV_LOG_PLAIN.set(true);
+    Env.TRV_LOG_TIME.clear();
+  }
+
+  async main(importOrFile: string, diff: string): Promise<void> {
+    const diffSource: TestDiffSource = await JSONUtil.readFile(diff);
+    const importPath = RuntimeIndex.getFromImportOrSource(importOrFile)?.import!;
+
+    return runTests(
+      {
+        consumer: this.format,
+        consumerOptions: CliUtil.readExtendedOptions(this.formatOptions),
+      },
+      {
+        import: importPath,
+        diffSource
+      }
+    );
+  }
+}

package/support/cli.test_digest.ts

@@ -4,7 +4,7 @@ import { Registry } from '@travetto/registry';
 import { IsPrivate } from '@travetto/schema';
 
 import { SuiteRegistryIndex } from '../src/registry/registry-index.ts';
-import { RunnerUtil } from '../src/execute/util.ts';
+import { RunUtil } from '../src/execute/run.ts';
 
 @CliCommand()
 @IsPrivate()
@@ -19,11 +19,11 @@ export class TestDigestCommand {
 
   async main(globs: string[] = ['**/*']) {
     // Load all tests
-    for await (const imp of await RunnerUtil.getTestImports(globs)) {
+    for await (const imp of await RunUtil.getTestImports(globs)) {
       try {
         await Runtime.importFrom(imp);
-      } catch (err) {
-        console.error('Failed to import', imp, err);
+      } catch (error) {
+        console.error('Failed to import', imp, error);
       }
     }
 
@@ -31,9 +31,9 @@ export class TestDigestCommand {
 
     const suites = SuiteRegistryIndex.getClasses();
     const all = suites
-      .map(c => SuiteRegistryIndex.getConfig(c))
-      .filter(c => !describeFunction(c.class).abstract)
-      .flatMap(c => Object.values(c.tests))
+      .map(cls => SuiteRegistryIndex.getConfig(cls))
+      .filter(config => !describeFunction(config.class).abstract)
+      .flatMap(config => Object.values(config.tests))
       .toSorted((a, b) => {
         const classComp = a.classId.localeCompare(b.classId);
         return classComp !== 0 ? classComp : a.methodName.localeCompare(b.methodName);

package/support/cli.test_direct.ts

@@ -1,5 +1,5 @@
-import { Env } from '@travetto/runtime';
-import { CliCommand } from '@travetto/cli';
+import { Env, RuntimeIndex } from '@travetto/runtime';
+import { CliCommand, CliUtil } from '@travetto/cli';
 import { IsPrivate } from '@travetto/schema';
 
 import { runTests, selectConsumer } from './bin/run.ts';
@@ -9,7 +9,6 @@ import { runTests, selectConsumer } from './bin/run.ts';
 @IsPrivate()
 export class TestDirectCommand {
 
-  @IsPrivate()
   format: string = 'tap';
 
   /**
@@ -30,17 +29,19 @@ export class TestDirectCommand {
   }
 
   main(importOrFile: string, clsId?: string, methodsNames: string[] = []): Promise<void> {
-
-    const options = Object.fromEntries((this.formatOptions ?? [])?.map(f => [...f.split(':'), true]));
-
-    return runTests({
-      consumer: this.format,
-      consumerOptions: options,
-      target: {
-        import: importOrFile,
+    // Resolve to import
+    const importPath = RuntimeIndex.getFromImportOrSource(importOrFile)?.import!;
+
+    return runTests(
+      {
+        consumer: this.format,
+        consumerOptions: CliUtil.readExtendedOptions(this.formatOptions),
+      },
+      {
+        import: importPath,
         classId: clsId,
         methodNames: methodsNames,
       }
-    });
+    );
   }
 }

package/support/cli.test_watch.ts

@@ -1,5 +1,5 @@
 import { Env } from '@travetto/runtime';
-import { CliCommand, CliUtil } from '@travetto/cli';
+import { CliCommand } from '@travetto/cli';
 
 import { selectConsumer } from './bin/run.ts';
 
@@ -18,19 +18,14 @@ export class TestWatcherCommand {
 
   preMain(): void {
     Env.TRV_ROLE.set('test');
-    Env.TRV_DYNAMIC.set(true);
   }
 
   async main(): Promise<void> {
-    if (await CliUtil.runWithRestart(this, true)) {
-      return;
-    }
-
     try {
       const { TestWatcher } = await import('../src/execute/watcher.ts');
       await TestWatcher.watch(this.format, this.mode === 'all');
-    } catch (err) {
-      console.error(err);
+    } catch (error) {
+      console.error(error);
     }
   }
 }

package/support/transformer.assert.ts

@@ -96,10 +96,10 @@ export class AssertTransformer {
   static lookupOpToken(key: number): string | undefined {
     if (OP_TOKEN_TO_NAME.size === 0) {
       Object.keys(ts.SyntaxKind)
-        .filter(x => !/^\d+$/.test(x))
-        .filter((x): x is keyof typeof OPTOKEN_ASSERT => !/^(Last|First)/.test(x))
-        .forEach(x =>
-          OP_TOKEN_TO_NAME.set(ts.SyntaxKind[x], x));
+        .filter(kind => !/^\d+$/.test(kind))
+        .filter((kind): kind is keyof typeof OPTOKEN_ASSERT => !/^(Last|First)/.test(kind))
+        .forEach(kind =>
+          OP_TOKEN_TO_NAME.set(ts.SyntaxKind[kind], kind));
     }
 
     const name = OP_TOKEN_TO_NAME.get(key)!;
@@ -123,10 +123,10 @@ export class AssertTransformer {
 
     // If looking at an identifier, see if it's in a diff file or if its const
     if (!found && ts.isIdentifier(node)) {
-      found = !!state.getDeclarations(node).find(x =>
+      found = !!state.getDeclarations(node).find(declaration =>
         // In a separate file or is const
-        x.getSourceFile().fileName !== state.source.fileName ||
-        DeclarationUtil.isConstantDeclaration(x));
+        declaration.getSourceFile().fileName !== state.source.fileName ||
+        DeclarationUtil.isConstantDeclaration(declaration));
     }
 
     return found;
@@ -137,7 +137,7 @@ export class AssertTransformer {
    */
   static initState(state: TransformerState & AssertState): void {
     if (!state[AssertSymbol]) {
-      const asrt = state.importFile('@travetto/test/src/assert/check.ts').ident;
+      const asrt = state.importFile('@travetto/test/src/assert/check.ts').identifier;
       state[AssertSymbol] = {
         assert: asrt,
         assertCheck: CoreUtil.createAccess(state.factory, asrt, ASSERT_UTIL, 'check'),
@@ -156,7 +156,7 @@ export class AssertTransformer {
     const first = CoreUtil.firstArgument(node);
     const firstText = first?.getText() ?? node.getText();
 
-    cmd.args = cmd.args.filter(x => x !== undefined && x !== null);
+    cmd.args = cmd.args.filter(arg => arg !== undefined && arg !== null);
     const check = state.factory.createCallExpression(state[AssertSymbol]!.assertCheck, undefined, state.factory.createNodeArray([
       state.fromLiteral({
         module: state.getModuleIdentifier(),
@@ -236,7 +236,7 @@ export class AssertTransformer {
       const matched = METHODS[key.text!];
       if (matched) {
         const resolved = state.resolveType(root);
-        if (resolved.key === 'literal' && matched.find(x => resolved.ctor === x)) { // Ensure method is against real type
+        if (resolved.key === 'literal' && matched.find(type => resolved.ctor === type)) { // Ensure method is against real type
           switch (key.text) {
             case 'includes': return { fn: key.text, args: [comp.expression.expression, comp.arguments[0], ...args.slice(1)] };
             case 'test': return { fn: key.text, args: [comp.arguments[0], comp.expression.expression, ...args.slice(1)] };
@@ -298,9 +298,9 @@ export class AssertTransformer {
       }
       // If calling `assert.*`
     } else if (ts.isPropertyAccessExpression(exp) && ts.isIdentifier(exp.expression)) { // Assert method call
-      const ident = exp.expression;
+      const identifier = exp.expression;
       const fn = exp.name.escapedText.toString();
-      if (ident.escapedText === ASSERT_CMD) {
+      if (identifier.escapedText === ASSERT_CMD) {
         // Look for reject/throw
         if (fn === 'fail') {
           node = this.doAssert(state, node, { fn: 'fail', args: node.arguments.slice() });

package/src/execute/runner.ts

@@ -1,87 +0,0 @@
-import path from 'node:path';
-
-import { TimeUtil, Runtime, RuntimeIndex } from '@travetto/runtime';
-import { WorkPool } from '@travetto/worker';
-
-import { buildStandardTestManager } from '../worker/standard.ts';
-import { RunnableTestConsumer } from '../consumer/types/runnable.ts';
-import { TestRun } from '../model/test.ts';
-
-import { TestExecutor } from './executor.ts';
-import { RunnerUtil } from './util.ts';
-import { RunState } from './types.ts';
-import { TestConsumerRegistryIndex } from '../consumer/registry-index.ts';
-
-/**
- * Test Runner
- */
-export class Runner {
-
-  #state: RunState;
-
-  constructor(state: RunState) {
-    this.#state = state;
-  }
-
-  /**
-   * Run all files
-   */
-  async runFiles(globs?: string[]): Promise<boolean> {
-    const target = await TestConsumerRegistryIndex.getInstance(this.#state);
-    const consumer = new RunnableTestConsumer(target);
-    const tests = await RunnerUtil.getTestDigest(globs, this.#state.tags);
-    const testRuns = RunnerUtil.getTestRuns(tests)
-      .toSorted((a, b) => a.runId!.localeCompare(b.runId!));
-
-    await consumer.onStart({ testCount: tests.length });
-    await WorkPool.run(
-      f => buildStandardTestManager(consumer, f),
-      testRuns,
-      {
-        idleTimeoutMillis: TimeUtil.asMillis(10, 's'),
-        min: 1,
-        max: this.#state.concurrency
-      });
-
-    return consumer.summarizeAsBoolean();
-  }
-
-  /**
-   * Run a single file
-   */
-  async runSingle(run: TestRun): Promise<boolean> {
-    run.import =
-      RuntimeIndex.getFromImport(run.import)?.import ??
-      RuntimeIndex.getFromSource(path.resolve(run.import))?.import!;
-
-    const entry = RuntimeIndex.getFromImport(run.import)!;
-
-    if (entry.module !== Runtime.main.name) {
-      RuntimeIndex.reinitForModule(entry.module);
-    }
-
-    const target = await TestConsumerRegistryIndex.getInstance(this.#state);
-
-    const consumer = new RunnableTestConsumer(target)
-      .withTransformer(e => {
-        // Copy run metadata to event
-        e.metadata = run.metadata;
-        return e;
-      });
-
-    await consumer.onStart({});
-    await new TestExecutor(consumer).execute(run);
-    return consumer.summarizeAsBoolean();
-  }
-
-  /**
-   * Run the runner, based on the inputs passed to the constructor
-   */
-  async run(): Promise<boolean | undefined> {
-    if ('import' in this.#state.target) {
-      return await this.runSingle(this.#state.target);
-    } else {
-      return await this.runFiles(this.#state.target.globs);
-    }
-  }
-}

package/src/execute/util.ts

@@ -1,108 +0,0 @@
-import { spawn } from 'node:child_process';
-import { createReadStream } from 'node:fs';
-import fs from 'node:fs/promises';
-import readline from 'node:readline/promises';
-import path from 'node:path';
-
-import { Env, ExecUtil, ShutdownManager, Util, RuntimeIndex, Runtime } from '@travetto/runtime';
-import { TestConfig, TestRun } from '../model/test.ts';
-
-/**
- * Simple Test Utilities
- */
-export class RunnerUtil {
-  /**
-   * Add 50 ms to the shutdown to allow for buffers to output properly
-   */
-  static registerCleanup(scope: string): void {
-    ShutdownManager.onGracefulShutdown(() => Util.blockingTimeout(50), `test.${scope}.bufferOutput`);
-  }
-
-  /**
-   * Determine if a given file path is a valid test file
-   */
-  static async isTestFile(file: string): Promise<boolean> {
-    const reader = readline.createInterface({ input: createReadStream(file) });
-    const state = { imp: false, suite: false };
-    for await (const line of reader) {
-      state.imp ||= line.includes('@travetto/test');
-      state.suite ||= line.includes('Suite'); // Decorator or name
-      if (state.imp && state.suite) {
-        reader.close();
-        return true;
-      }
-    }
-    return false;
-  }
-
-  /**
-   * Find all valid test files given the globs
-   */
-  static async* getTestImports(globs?: string[]): AsyncIterable<string> {
-    const all = RuntimeIndex.find({
-      module: m => m.roles.includes('test') || m.roles.includes('std'),
-      folder: f => f === 'test',
-      file: f => f.role === 'test'
-    });
-
-    // Collect globs
-    if (globs?.length) {
-      const allFiles = new Map(all.map(x => [x.sourceFile, x]));
-      for await (const item of fs.glob(globs)) {
-        const src = Runtime.workspaceRelative(path.resolve(item));
-        const match = allFiles.get(src);
-        if (match && await this.isTestFile(match.sourceFile)) {
-          yield match.import;
-        }
-      }
-    } else {
-      for await (const match of all) {
-        if (await this.isTestFile(match.sourceFile)) {
-          yield match.import;
-        }
-      }
-    }
-  }
-
-  /**
-   * Get count of tests for a given set of globs
-   * @param globs
-   * @returns
-   */
-  static async getTestDigest(globs: string[] = ['**/*.ts'], tags?: string[]): Promise<TestConfig[]> {
-    const countRes = await ExecUtil.getResult(
-      spawn('npx', ['trv', 'test:digest', '-o', 'json', ...globs], {
-        env: { ...process.env, ...Env.FORCE_COLOR.export(0), ...Env.NO_COLOR.export(true) }
-      }),
-      { catch: true }
-    );
-    if (!countRes.valid) {
-      throw new Error(countRes.stderr);
-    }
-
-    const testFilter = tags?.length ?
-      Util.allowDeny<string, [TestConfig]>(
-        tags,
-        rule => rule,
-        (rule, core) => core.tags?.includes(rule) ?? false
-      ) :
-      ((): boolean => true);
-
-    const parsed: TestConfig[] = countRes.valid ? JSON.parse(countRes.stdout) : [];
-    return parsed.filter(testFilter);
-  }
-
-  /**
-   * Get run events
-   */
-  static getTestRuns(tests: TestConfig[]): TestRun[] {
-    const events = tests.reduce((acc, test) => {
-      if (!acc.has(test.classId)) {
-        acc.set(test.classId, { import: test.import, classId: test.classId, methodNames: [], runId: Util.uuid() });
-      }
-      acc.get(test.classId)!.methodNames!.push(test.methodName);
-      return acc;
-    }, new Map<string, TestRun>());
-    return [...events.values()];
-  }
-}