@travetto/test 8.0.0-alpha.20 → 8.0.0-alpha.21

package/src/execute/run.ts

@@ -1,21 +1,21 @@
 import { createReadStream } from 'node:fs';
 import fs from 'node:fs/promises';
-import readline from 'node:readline/promises';
 import path from 'node:path';
+import readline from 'node:readline/promises';
 
-import { Env, ExecUtil, Util, RuntimeIndex, Runtime, TimeUtil, JSONUtil, describeFunction } from '@travetto/runtime';
-import { WorkPool } from '@travetto/worker';
 import { Registry } from '@travetto/registry';
+import { describeFunction, Env, ExecUtil, JSONUtil, Runtime, RuntimeIndex, TimeUtil, Util } from '@travetto/runtime';
+import { WorkPool } from '@travetto/worker';
 
-import type { TestConfig, TestRunInput, TestRun, TestGlobInput, TestDiffInput } from '../model/test.ts';
-import type { TestRemoveEvent } from '../model/event.ts';
-import type { TestConsumerShape } from '../consumer/types.ts';
-import { RunnableTestConsumer } from '../consumer/types/runnable.ts';
-import type { TestConsumerConfig } from './types.ts';
 import { TestConsumerRegistryIndex } from '../consumer/registry-index.ts';
-import { TestExecutor } from './executor.ts';
-import { buildStandardTestManager } from '../worker/standard.ts';
+import { RunnableTestConsumer } from '../consumer/types/runnable.ts';
+import type { TestConsumerShape } from '../consumer/types.ts';
+import type { TestRemoveEvent } from '../model/event.ts';
+import type { TestConfig, TestDiffInput, TestGlobInput, TestRun, TestRunInput } from '../model/test.ts';
 import { SuiteRegistryIndex } from '../registry/registry-index.ts';
+import { buildStandardTestManager } from '../worker/standard.ts';
+import { TestExecutor } from './executor.ts';
+import type { TestConsumerConfig } from './types.ts';
 
 type RunState = {
   runs: TestRun[];
@@ -26,7 +26,6 @@ type RunState = {
  * Test Utilities for Running
  */
 export class RunUtil {
-
   /**
    * Determine if a given file path is a valid test file
    */
@@ -47,7 +46,7 @@ export class RunUtil {
   /**
    * Find all valid test files given the globs
    */
-  static async* getTestImports(globs?: string[]): AsyncIterable<string> {
+  static async *getTestImports(globs?: string[]): AsyncIterable<string> {
     const all = RuntimeIndex.find({
       module: module => module.roles.includes('test') || module.roles.includes('std'),
       folder: folder => folder === 'test',
@@ -60,7 +59,7 @@ export class RunUtil {
       for await (const item of fs.glob(globs)) {
         const source = Runtime.workspaceRelative(path.resolve(item));
         const match = allFiles.get(source);
-        if (match && await this.isTestFile(match.sourceFile)) {
+        if (match && (await this.isTestFile(match.sourceFile))) {
           yield match.import;
         }
       }
@@ -80,7 +79,7 @@ export class RunUtil {
   static async resolveGlobInput({ globs, tags, metadata }: TestGlobInput): Promise<TestRun[]> {
     const digestProcess = await ExecUtil.getResult(
       ExecUtil.spawnPackageCommand('trv', ['test:digest', '-o', 'json', ...globs], {
-        env: { ...process.env, ...Env.FORCE_COLOR.export(0), ...Env.NO_COLOR.export(true) },
+        env: { ...process.env, ...Env.FORCE_COLOR.export(0), ...Env.NO_COLOR.export(true) }
       }),
       { catch: true }
     );
@@ -89,20 +88,20 @@ export class RunUtil {
       throw new Error(digestProcess.stderr);
     }
 
-    const testFilter = tags?.length ?
-      Util.allowDeny<string, [TestConfig]>(
-        tags,
-        rule => rule,
-        (rule, core) => core.tags?.includes(rule) ?? false
-      ) :
-      ((): boolean => true);
+    const testFilter = tags?.length
+      ? Util.allowDeny<string, [TestConfig]>(
+          tags,
+          rule => rule,
+          (rule, core) => core.tags?.includes(rule) ?? false
+        )
+      : (): boolean => true;
 
     const parsed: TestConfig[] = JSONUtil.fromUTF8(digestProcess.stdout);
 
     const events = parsed.filter(testFilter).reduce((runs, test) => {
-      runs.getOrInsert(test.classId,
-        { import: test.import, classId: test.classId, methodNames: [], runId: Util.uuid(), metadata }
-      ).methodNames!.push(test.methodName);
+      runs
+        .getOrInsert(test.classId, { import: test.import, classId: test.classId, methodNames: [], runId: Util.uuid(), metadata })
+        .methodNames!.push(test.methodName);
       return runs;
     }, new Map<string, TestRun>());
 
@@ -141,18 +140,22 @@ export class RunUtil {
     // Looking at Diff
     for (const [clsId, config] of Object.entries(diff)) {
       const local = classes[clsId];
-      if (!local) { // Removed classes
+      if (!local) {
+        // Removed classes
         removeTest(clsId);
-      } else if (local.sourceHash !== config.sourceHash) { // Class changed or added
+      } else if (local.sourceHash !== config.sourceHash) {
+        // Class changed or added
         // Methods to run, defaults to newly added
         const methods: string[] = Object.keys(local.tests ?? {}).filter(key => !config.methods[key]);
         let didRemove = false;
         for (const key of Object.keys(config.methods)) {
           const localMethod = local.tests?.[key];
-          if (!localMethod) { // Test is removed
+          if (!localMethod) {
+            // Test is removed
             removeTest(clsId, key);
             didRemove = true;
-          } else if (localMethod.sourceHash !== config.methods[key]) { // Method changed or added
+          } else if (localMethod.sourceHash !== config.methods[key]) {
+            // Method changed or added
             methods.push(key);
           }
         }
@@ -162,7 +165,8 @@ export class RunUtil {
       }
     }
 
-    if (runs.length === 0 && removes.length === 0) { // Re-run entire file, classes unchanged
+    if (runs.length === 0 && removes.length === 0) {
+      // Re-run entire file, classes unchanged
       addRun(undefined);
     }
 
@@ -225,17 +229,13 @@ export class RunUtil {
     if (runs.length === 1) {
       await new TestExecutor(consumer).execute(runs[0], true);
     } else {
-      await WorkPool.run(
-        run => buildStandardTestManager(consumer, run),
-        runs,
-        {
-          idleTimeoutMillis: TimeUtil.duration('10s', 'ms'),
-          min: 1,
-          max: consumerConfig.concurrency
-        }
-      );
+      await WorkPool.run(run => buildStandardTestManager(consumer, run), runs, {
+        idleTimeoutMillis: TimeUtil.duration('10s', 'ms'),
+        min: 1,
+        max: consumerConfig.concurrency
+      });
     }
 
     return consumer.summarizeAsBoolean();
   }
-}
+}

package/src/execute/watcher.ts

@@ -1,14 +1,14 @@
 import { ManifestModuleUtil } from '@travetto/manifest';
 import { Registry } from '@travetto/registry';
-import { WorkPool } from '@travetto/worker';
 import { AsyncQueue, TimeUtil, WatchUtil } from '@travetto/runtime';
+import { WorkPool } from '@travetto/worker';
 
-import { buildStandardTestManager } from '../worker/standard.ts';
 import { TestConsumerRegistryIndex } from '../consumer/registry-index.ts';
 import { CumulativeSummaryConsumer } from '../consumer/types/cumulative.ts';
 import type { TestDiffInput, TestRun } from '../model/test.ts';
-import { RunUtil } from './run.ts';
+import { buildStandardTestManager } from '../worker/standard.ts';
 import { isTestRunEvent, type TestReadyEvent } from '../worker/types.ts';
+import { RunUtil } from './run.ts';
 
 /**
  * Test Watcher.
@@ -16,7 +16,6 @@ import { isTestRunEvent, type TestReadyEvent } from '../worker/types.ts';
  * Runs all tests on startup, and then listens for changes to run tests again
  */
 export class TestWatcher {
-
   /**
    * Start watching all test files
    */
@@ -28,13 +27,11 @@ export class TestWatcher {
     const events: (TestRun | TestDiffInput)[] = [];
 
     if (runAllOnStart) {
-      events.push(...await RunUtil.resolveGlobInput({ globs: [] }));
+      events.push(...(await RunUtil.resolveGlobInput({ globs: [] })));
     }
 
     const queue = new AsyncQueue(events);
-    const consumer = new CumulativeSummaryConsumer(
-      await TestConsumerRegistryIndex.getInstance({ consumer: format })
-    );
+    const consumer = new CumulativeSummaryConsumer(await TestConsumerRegistryIndex.getInstance({ consumer: format }));
 
     process.on('message', event => {
       if (isTestRunEvent(event)) {
@@ -44,19 +41,15 @@ export class TestWatcher {
 
     process.send?.({ type: 'ready' } satisfies TestReadyEvent);
 
-    const queueProcessor = WorkPool.run(
-      buildStandardTestManager.bind(null, consumer),
-      queue,
-      {
-        idleTimeoutMillis: TimeUtil.duration('2m', 'ms'),
-        min: 2,
-        max: WorkPool.DEFAULT_SIZE
-      }
-    );
+    const queueProcessor = WorkPool.run(buildStandardTestManager.bind(null, consumer), queue, {
+      idleTimeoutMillis: TimeUtil.duration('2m', 'ms'),
+      min: 2,
+      max: WorkPool.DEFAULT_SIZE
+    });
 
     await WatchUtil.watchCompilerEvents('change', event => {
       const fileType = ManifestModuleUtil.getFileType(event.file);
-      if ((fileType === 'ts' || fileType === 'js')) {
+      if (fileType === 'ts' || fileType === 'js') {
         if (event.action === 'delete') {
           consumer.removeTest(event.import);
         } else {
@@ -69,4 +62,4 @@ export class TestWatcher {
     // Cleanup
     await queueProcessor;
   }
-}
+}

package/src/fixture.ts

@@ -2,11 +2,10 @@ import { FileLoader, Runtime } from '@travetto/runtime';
 
 export class TestFixtures extends FileLoader {
   constructor(modules: string[] = []) {
-    super([
-      '@#test/fixtures',
-      '@#support/fixtures',
-      ...modules.flat().map(module => `${module}#support/fixtures`),
-      '@@#support/fixtures'
-    ].map(value => Runtime.modulePath(value)));
+    super(
+      ['@#test/fixtures', '@#support/fixtures', ...modules.flat().map(module => `${module}#support/fixtures`), '@@#support/fixtures'].map(
+        value => Runtime.modulePath(value)
+      )
+    );
   }
-}
+}

package/src/model/common.ts

@@ -47,4 +47,4 @@ export interface TestCore extends SuiteCore {
    * For extended suites, this is where the test is declared
    */
   declarationImport?: string;
-}
+}

package/src/model/error.ts

@@ -3,9 +3,9 @@ import { RuntimeError } from '@travetto/runtime';
 /**
  * Represents an execution error
  */
-export class TestExecutionError extends RuntimeError { }
+export class TestExecutionError extends RuntimeError {}
 
 /**
  * Timeout execution error
  */
-export class TimeoutError extends TestExecutionError { }
+export class TimeoutError extends TestExecutionError {}

package/src/model/event.ts

@@ -1,5 +1,5 @@
-import type { Assertion, TestConfig, TestResult } from './test.ts';
 import type { SuiteConfig, SuiteResult } from './suite.ts';
+import type { Assertion, TestConfig, TestResult } from './test.ts';
 
 /**
  * Targets
@@ -11,17 +11,22 @@ export type EventEntity = 'test' | 'suite' | 'assertion';
  */
 export type EventPhase = 'before' | 'after';
 
-type EventTpl<T extends EventEntity, P extends EventPhase, V extends {}> =
-  { type: T, phase: P, metadata?: Record<string, unknown> } & V;
+type EventTpl<T extends EventEntity, P extends EventPhase, V extends {}> = { type: T; phase: P; metadata?: Record<string, unknown> } & V;
 
-export type TestRemoveEvent = { type: 'removeTest', import: string, classId?: string, methodName?: string, metadata?: Record<string, unknown> };
+export type TestRemoveEvent = {
+  type: 'removeTest';
+  import: string;
+  classId?: string;
+  methodName?: string;
+  metadata?: Record<string, unknown>;
+};
 
 /**
  * Different test event shapes
  */
 export type TestEvent =
-  EventTpl<'assertion', 'after', { assertion: Assertion }> |
-  EventTpl<'test', 'before', { test: TestConfig }> |
-  EventTpl<'test', 'after', { test: TestResult }> |
-  EventTpl<'suite', 'before', { suite: SuiteConfig }> |
-  EventTpl<'suite', 'after', { suite: SuiteResult }>;
+  | EventTpl<'assertion', 'after', { assertion: Assertion }>
+  | EventTpl<'test', 'before', { test: TestConfig }>
+  | EventTpl<'test', 'after', { test: TestResult }>
+  | EventTpl<'suite', 'before', { suite: SuiteConfig }>
+  | EventTpl<'suite', 'after', { suite: SuiteResult }>;

package/src/model/suite.ts

@@ -1,7 +1,7 @@
 import type { Any, Class } from '@travetto/runtime';
 
-import type { TestConfig, TestResult, TestStatus } from './test.ts';
 import type { Skip, SuiteCore } from './common.ts';
+import type { TestConfig, TestResult, TestStatus } from './test.ts';
 
 export type SuitePhase = 'beforeAll' | 'beforeEach' | 'afterAll' | 'afterEach';
 
@@ -63,4 +63,4 @@ export interface SuiteResult extends ResultsSummary, SuiteCore {
    * Overall status
    */
   status: TestStatus;
-}
+}

package/src/model/test.ts

@@ -5,10 +5,13 @@ import type { Skip, TestCore } from './common.ts';
 export type ThrowableError = string | RegExp | Class<Error> | ((error: Error | string) => boolean | void | undefined);
 export type TestLog = Omit<ConsoleEvent, 'args' | 'scope'> & { message: string };
 
-export type TestDiffSource = Record<string, {
-  sourceHash: number;
-  methods: Record<string, number>;
-}>;
+export type TestDiffSource = Record<
+  string,
+  {
+    sourceHash: number;
+    methods: Record<string, number>;
+  }
+>;
 
 export type TestStatus = 'passed' | 'skipped' | 'errored' | 'failed' | 'unknown';
 
@@ -184,4 +187,4 @@ export type TestGlobInput = {
   metadata?: Record<string, unknown>;
 };
 
-export type TestRunInput = TestRun | TestDiffInput | TestGlobInput;
+export type TestRunInput = TestRun | TestDiffInput | TestGlobInput;

package/src/model/util.ts

@@ -8,11 +8,16 @@ import type { TestConfig, TestResult, TestRun, TestStatus } from './test.ts';
 export class TestModelUtil {
   static computeTestStatus(summary: ResultsSummary): TestStatus {
     switch (true) {
-      case summary.errored > 0: return 'errored';
-      case summary.failed > 0: return 'failed';
-      case summary.skipped > 0: return 'skipped';
-      case summary.unknown > 0: return 'unknown';
-      default: return 'passed';
+      case summary.errored > 0:
+        return 'errored';
+      case summary.failed > 0:
+        return 'failed';
+      case summary.skipped > 0:
+        return 'skipped';
+      case summary.unknown > 0:
+        return 'unknown';
+      default:
+        return 'passed';
     }
   }
 
@@ -24,13 +29,12 @@ export class TestModelUtil {
     for (const test of tests) {
       summary[test.status] += 1;
       summary.total += 1;
-      summary.selfDuration += (test.selfDuration ?? 0);
-      summary.duration += (test.duration ?? 0);
+      summary.selfDuration += test.selfDuration ?? 0;
+      summary.duration += test.duration ?? 0;
     }
     return summary;
   }
 
-
   /**
    * An empty suite result based on a suite config
    */
@@ -81,17 +85,23 @@ export class TestModelUtil {
     const common = { classId, duration: 0, lineStart: 1, lineEnd: 1, import: run.import } as const;
     return asFull<SuiteResult>({
       ...common,
-      status: 'errored', errored: 1,
+      status: 'errored',
+      errored: 1,
       tests: {
         impport: asFull<TestResult>({
           ...common,
           status: 'errored',
-          assertions: [{
-            ...common, line: common.lineStart,
-            methodName: 'import', operator: 'import', text: `Failed to import ${run.import}`,
-          }]
+          assertions: [
+            {
+              ...common,
+              line: common.lineStart,
+              methodName: 'import',
+              operator: 'import',
+              text: `Failed to import ${run.import}`
+            }
+          ]
         })
       }
     });
   }
-}
+}

package/src/registry/registry-adapter.ts

@@ -1,5 +1,5 @@
 import type { RegistryAdapter } from '@travetto/registry';
-import { RuntimeError, asFull, type Class, describeFunction, Runtime, safeAssign } from '@travetto/runtime';
+import { asFull, type Class, describeFunction, Runtime, RuntimeError, safeAssign } from '@travetto/runtime';
 import { SchemaRegistryIndex } from '@travetto/schema';
 
 import type { SuiteConfig } from '../model/suite.ts';
@@ -8,7 +8,7 @@ import type { TestConfig } from '../model/test.ts';
 function combineClasses(baseConfig: SuiteConfig, ...subConfig: Partial<SuiteConfig>[]): SuiteConfig {
   for (const config of subConfig) {
     if (config.tags) {
-      baseConfig.tags = [...new Set([...baseConfig.tags ?? [], ...config.tags])];
+      baseConfig.tags = [...new Set([...(baseConfig.tags ?? []), ...config.tags])];
     }
     baseConfig.skip = config.skip ?? baseConfig.skip;
 
@@ -22,7 +22,7 @@ function combineClasses(baseConfig: SuiteConfig, ...subConfig: Partial<SuiteConf
           ...test,
           class: baseConfig.class,
           classId: baseConfig.classId,
-          import: baseConfig.import,
+          import: baseConfig.import
         };
       }
     }
@@ -31,7 +31,7 @@ function combineClasses(baseConfig: SuiteConfig, ...subConfig: Partial<SuiteConf
 }
 
 function combineWithParent(baseConfig: SuiteConfig, parentConfig: SuiteConfig): SuiteConfig {
-  baseConfig.tags = [...parentConfig.tags ?? [], ...baseConfig.tags ?? []];
+  baseConfig.tags = [...(parentConfig.tags ?? []), ...(baseConfig.tags ?? [])];
   baseConfig.skip = baseConfig.skip ?? parentConfig.skip;
   baseConfig.phaseHandlers = [...(parentConfig.phaseHandlers ?? []), ...(baseConfig.phaseHandlers ?? [])];
   for (const [key, test] of Object.entries(parentConfig.tests ?? {})) {
@@ -39,7 +39,7 @@ function combineWithParent(baseConfig: SuiteConfig, parentConfig: SuiteConfig):
       ...test,
       class: baseConfig.class,
       classId: baseConfig.classId,
-      import: baseConfig.import,
+      import: baseConfig.import
     };
   }
   return baseConfig;
@@ -50,10 +50,7 @@ function combineMethods(suite: SuiteConfig, baseConfig: TestConfig, ...subConfig
   baseConfig.import = suite.import;
   for (const config of subConfig) {
     safeAssign(baseConfig, config, {
-      tags: [
-        ...baseConfig.tags ?? [],
-        ...config.tags ?? []
-      ]
+      tags: [...(baseConfig.tags ?? []), ...(config.tags ?? [])]
     });
   }
   return baseConfig;
@@ -80,7 +77,7 @@ export class SuiteRegistryAdapter implements RegistryAdapter<SuiteConfig> {
         lineEnd: lines?.[1],
         sourceHash: hash,
         tests: {},
-        phaseHandlers: [],
+        phaseHandlers: []
       });
     }
     combineClasses(this.#config, ...data);
@@ -102,7 +99,7 @@ export class SuiteRegistryAdapter implements RegistryAdapter<SuiteConfig> {
         lineEnd: lines?.[1],
         lineBodyStart: lines?.[2],
         methodName: method,
-        sourceHash: hash,
+        sourceHash: hash
       });
       this.#config.tests[method] = config;
     }
@@ -118,7 +115,7 @@ export class SuiteRegistryAdapter implements RegistryAdapter<SuiteConfig> {
     }
 
     for (const test of Object.values(this.#config.tests)) {
-      test.tags = [...new Set([...test.tags ?? [], ...this.#config.tags ?? []])];
+      test.tags = [...new Set([...(test.tags ?? []), ...(this.#config.tags ?? [])])];
       test.description ||= SchemaRegistryIndex.get(this.#cls).getMethod(test.methodName).description;
     }
   }
@@ -134,4 +131,4 @@ export class SuiteRegistryAdapter implements RegistryAdapter<SuiteConfig> {
     }
     return test;
   }
-}
+}

package/src/registry/registry-index.ts

@@ -1,20 +1,18 @@
-import { RuntimeError, type Class, Runtime, describeFunction } from '@travetto/runtime';
-import { type RegistryIndex, RegistryIndexStore, Registry } from '@travetto/registry';
+import { Registry, type RegistryIndex, RegistryIndexStore } from '@travetto/registry';
+import { type Class, describeFunction, Runtime, RuntimeError } from '@travetto/runtime';
 
 import type { SuiteConfig } from '../model/suite.ts';
 import type { TestConfig, TestRun } from '../model/test.ts';
 import { SuiteRegistryAdapter } from './registry-adapter.ts';
 
-const sortedTests = (config: SuiteConfig): TestConfig[] =>
-  Object.values(config.tests).toSorted((a, b) => a.lineStart - b.lineStart);
+const sortedTests = (config: SuiteConfig): TestConfig[] => Object.values(config.tests).toSorted((a, b) => a.lineStart - b.lineStart);
 
-type SuiteTests = { suite: SuiteConfig, tests: TestConfig[] };
+type SuiteTests = { suite: SuiteConfig; tests: TestConfig[] };
 
 /**
  * Test Suite registry
  */
 export class SuiteRegistryIndex implements RegistryIndex {
-
   static #instance = Registry.registerIndex(this);
 
   static getForRegister(cls: Class): SuiteRegistryAdapter {
@@ -43,7 +41,9 @@ export class SuiteRegistryIndex implements RegistryIndex {
 
   store = new RegistryIndexStore(SuiteRegistryAdapter);
 
-  /** @private */ constructor(source: unknown) { Registry.validateConstructor(source); }
+  /** @private */ constructor(source: unknown) {
+    Registry.validateConstructor(source);
+  }
 
   /**
    * Find all valid tests (ignoring abstract)
@@ -64,7 +64,8 @@ export class SuiteRegistryIndex implements RegistryIndex {
     const imp = run.import;
     const methodNames = run.methodNames ?? [];
 
-    if (clsId && /^\d+$/.test(clsId)) { // If we only have a line number
+    if (clsId && /^\d+$/.test(clsId)) {
+      // If we only have a line number
       const line = parseInt(clsId, 10);
       const suites = this.getValidClasses()
         .filter(cls => Runtime.getImport(cls) === imp)
@@ -79,7 +80,8 @@ export class SuiteRegistryIndex implements RegistryIndex {
       } else {
         return suites.map(config => ({ suite: config, tests: sortedTests(config) }));
       }
-    } else { // Else lookup directly
+    } else {
+      // Else lookup directly
       if (methodNames.length) {
         const cls = this.getValidClasses().find(type => type.Ⲑid === clsId);
         if (!cls) {
@@ -98,7 +100,7 @@ export class SuiteRegistryIndex implements RegistryIndex {
       } else {
         const suites = this.getValidClasses()
           .map(type => this.getConfig(type))
-          .filter(config => !describeFunction(config.class).abstract);  // Do not run abstract suites
+          .filter(config => !describeFunction(config.class).abstract); // Do not run abstract suites
         return suites.map(config => ({ suite: config, tests: sortedTests(config) }));
       }
     }
@@ -114,4 +116,4 @@ export class SuiteRegistryIndex implements RegistryIndex {
       return Object.values(config.tests).find(item => item.methodName === methodName);
     }
   }
-}
+}

package/src/worker/child.ts

@@ -1,18 +1,17 @@
 import { createWriteStream } from 'node:fs';
 
-import { JSONUtil, ConsoleManager, Env, Runtime } from '@travetto/runtime';
+import { ConsoleManager, Env, JSONUtil, Runtime } from '@travetto/runtime';
 import { IpcChannel } from '@travetto/worker';
 
 import { RunUtil } from '../execute/run.ts';
-import { TestWorkerEvents } from './types.ts';
 import type { TestRun } from '../model/test.ts';
+import { TestWorkerEvents } from './types.ts';
 
 /**
  * Child Worker for the Test Runner.  Receives events as commands
  * to run specific tests
  */
 export class TestChildWorker extends IpcChannel<TestRun> {
-
   #done = Promise.withResolvers<void>();
 
   async #exec(operation: () => Promise<unknown>, type: string): Promise<void> {
@@ -20,7 +19,9 @@ export class TestChildWorker extends IpcChannel<TestRun> {
       await operation();
       this.send(type); // Respond
     } catch (error) {
-      if (!(error instanceof Error)) { throw error; }
+      if (!(error instanceof Error)) {
+        throw error;
+      }
       // Mark as errored out
       this.send(type, JSONUtil.cloneForTransmit(error));
     }
@@ -34,9 +35,9 @@ export class TestChildWorker extends IpcChannel<TestRun> {
       const file = Runtime.toolPath(`test-worker.${process.pid}.log`);
       const stdout = createWriteStream(file, { flags: 'a' });
       const cons = new console.Console({ stdout, inspectOptions: { depth: 4, colors: false } });
-      ConsoleManager.set({ log: (event) => cons[event.level](process.pid, ...event.args) });
+      ConsoleManager.set({ log: event => cons[event.level](process.pid, ...event.args) });
     } else {
-      ConsoleManager.set({ log: () => { } });
+      ConsoleManager.set({ log: () => {} });
     }
 
     // Listen for inbound requests
@@ -54,9 +55,11 @@ export class TestChildWorker extends IpcChannel<TestRun> {
   async onCommand(event: TestRun & { type: string }): Promise<boolean> {
     console.debug('on message', { ...event });
 
-    if (event.type === TestWorkerEvents.INIT) { // On request to init, start initialization
+    if (event.type === TestWorkerEvents.INIT) {
+      // On request to init, start initialization
       await this.#exec(() => this.onInitCommand(), TestWorkerEvents.INIT_COMPLETE);
-    } else if (event.type === TestWorkerEvents.RUN) { // On request to run, start running
+    } else if (event.type === TestWorkerEvents.RUN) {
+      // On request to run, start running
       await this.#exec(() => this.onRunCommand(event), TestWorkerEvents.RUN_COMPLETE);
     }
 
@@ -66,7 +69,7 @@ export class TestChildWorker extends IpcChannel<TestRun> {
   /**
    * In response to the initialization command
    */
-  async onInitCommand(): Promise<void> { }
+  async onInitCommand(): Promise<void> {}
 
   /**
    * Run a specific test/suite
@@ -80,4 +83,4 @@ export class TestChildWorker extends IpcChannel<TestRun> {
       this.#done.resolve();
     }
   }
-}
+}