@travetto/test 8.0.0-alpha.9 → 8.0.0

package/src/execute/executor.ts

@@ -1,17 +1,17 @@
-import { Env, TimeUtil, Runtime, castTo, classConstruct } from '@travetto/runtime';
 import { Registry } from '@travetto/registry';
+import { castTo, classConstruct, Env, Runtime, TimeUtil } from '@travetto/runtime';
 
-import type { TestConfig, TestResult, TestRun } from '../model/test.ts';
-import type { SuiteConfig, SuiteResult } from '../model/suite.ts';
-import type { TestConsumerShape } from '../consumer/types.ts';
-import { AssertCheck } from '../assert/check.ts';
 import { AssertCapture } from '../assert/capture.ts';
-import { ConsoleCapture } from './console.ts';
-import { TestPhaseManager } from './phase.ts';
+import { AssertCheck } from '../assert/check.ts';
 import { AssertUtil } from '../assert/util.ts';
-import { Barrier } from './barrier.ts';
-import { SuiteRegistryIndex } from '../registry/registry-index.ts';
+import type { TestConsumerShape } from '../consumer/types.ts';
+import type { SuiteConfig, SuiteResult } from '../model/suite.ts';
+import type { TestConfig, TestResult, TestRun } from '../model/test.ts';
 import { TestModelUtil } from '../model/util.ts';
+import { SuiteRegistryIndex } from '../registry/registry-index.ts';
+import { Barrier } from './barrier.ts';
+import { ConsoleCapture } from './console.ts';
+import { TestPhaseManager } from './phase.ts';
 
 const TEST_TIMEOUT = TimeUtil.duration(Env.TRV_TEST_TIMEOUT.value || 5000, 'ms');
 
@@ -19,7 +19,6 @@ const TEST_TIMEOUT = TimeUtil.duration(Env.TRV_TEST_TIMEOUT.value || 5000, 'ms')
  * Support execution of the tests
  */
 export class TestExecutor {
-
   #consumer: TestConsumerShape;
 
   constructor(consumer: TestConsumerShape) {
@@ -57,16 +56,15 @@ export class TestExecutor {
    * Execute the test, capture output, assertions and promises
    */
   async executeTest(instance: unknown, test: TestConfig, suite: SuiteConfig, override?: Partial<TestResult>): Promise<TestResult> {
-
     const result = TestModelUtil.createTestResult(suite, test, override);
 
     // Mark test start
     this.#consumer.onEvent({ type: 'test', phase: 'before', test });
 
-
     // Emit every assertion as it occurs
     const getAssertions = AssertCapture.collector(test, item =>
-      this.#consumer.onEvent({ type: 'assertion', phase: 'after', assertion: item }));
+      this.#consumer.onEvent({ type: 'assertion', phase: 'after', assertion: item })
+    );
 
     const consoleCapture = new ConsoleCapture().start(); // Capture all output from transpiled code
 
@@ -75,7 +73,9 @@ export class TestExecutor {
       if (result.error) {
         result.assertions.push(AssertUtil.generateAssertion({ suite, test, error: result.error }));
       }
-      for (const item of result.assertions ?? []) { AssertCapture.add(item); }
+      for (const item of result.assertions ?? []) {
+        AssertCapture.add(item);
+      }
     } else {
       // Run method and get result
       const startTime = Date.now();
@@ -101,7 +101,6 @@ export class TestExecutor {
    * Execute an entire suite
    */
   async executeSuite(suite: SuiteConfig, tests: TestConfig[]): Promise<void> {
-
     const instance = classConstruct(suite.class);
 
     const shouldSkip = await this.#shouldSkip(suite, instance);
@@ -110,7 +109,8 @@ export class TestExecutor {
 
     if (shouldSkip) {
       this.#consumer.onEvent({
-        phase: 'after', type: 'suite',
+        phase: 'after',
+        type: 'suite',
         suite: {
           ...result,
           status: 'skipped',
@@ -130,9 +130,7 @@ export class TestExecutor {
     const testResultOverrides: Record<string, Partial<TestResult>> = {};
 
     const validTestMethodNames = new Set(tests.map(t => t.methodName));
-    const testConfigs = Object.fromEntries(
-      Object.entries(suite.tests).filter(([key]) => validTestMethodNames.has(key))
-    );
+    const testConfigs = Object.fromEntries(Object.entries(suite.tests).filter(([key]) => validTestMethodNames.has(key)));
 
     // Mark suite start
     this.#consumer.onEvent({ phase: 'before', type: 'suite', suite: { ...suite, tests: testConfigs } });
@@ -162,7 +160,7 @@ export class TestExecutor {
 
       try {
         // Handle BeforeEach
-        testResultOverride.status || await manager.startPhase('each');
+        testResultOverride.status || (await manager.startPhase('each'));
       } catch (someError) {
         const testError = await manager.onError('each', someError);
         testResultOverride.error = testError;
@@ -174,9 +172,11 @@ export class TestExecutor {
 
       // Handle after each
       try {
-        testResultOverride.status || await manager.endPhase('each');
+        testResultOverride.status || (await manager.endPhase('each'));
       } catch (testError) {
-        if (!(testError instanceof Error)) { throw testError; };
+        if (!(testError instanceof Error)) {
+          throw testError;
+        }
         console.error('Failed to properly shutdown test', testError.message);
       }
 
@@ -189,7 +189,9 @@ export class TestExecutor {
       // Handle after all
       await manager.endPhase('all');
     } catch (suiteError) {
-      if (!(suiteError instanceof Error)) { throw suiteError; };
+      if (!(suiteError instanceof Error)) {
+        throw suiteError;
+      }
       console.error('Failed to properly shutdown test', suiteError.message);
     }
 
@@ -210,7 +212,9 @@ export class TestExecutor {
     try {
       await Runtime.importFrom(run.import);
     } catch (error) {
-      if (!(error instanceof Error)) { throw error; }
+      if (!(error instanceof Error)) {
+        throw error;
+      }
       const suite = TestModelUtil.createImportErrorSuiteResult(run);
       console.error(error);
       this.#consumer.onEvent({ type: 'suite', phase: 'after', suite });
@@ -235,4 +239,4 @@ export class TestExecutor {
       await this.executeSuite(suite, tests);
     }
   }
-}
+}

package/src/execute/phase.ts

@@ -60,7 +60,7 @@ export class TestPhaseManager {
    */
   async onError(phase: 'all' | 'each', error: unknown): Promise<Error> {
     if (!(error instanceof Error)) {
-      await this.endPhase(phase).catch(() => { });
+      await this.endPhase(phase).catch(() => {});
       throw error;
     }
     return error;

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 { TestConsumerRegistryIndex } from '../consumer/registry-index.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 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>({
+        import: 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;
   }
-}
+}