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

package/src/consumer/types/tap.ts

@@ -48,10 +48,10 @@ export class TapEmitter implements TestConsumerShape {
   /**
    * Output supplemental data (e.g. logs)
    */
-  logMeta(obj: Record<string, unknown>): void {
+  logMeta(meta: Record<string, unknown>): void {
     const lineLength = this.#terminal.width - 5;
-    let body = stringify(obj, { lineWidth: lineLength, indent: 2 });
-    body = body.split('\n').map(x => `  ${x}`).join('\n');
+    let body = stringify(meta, { lineWidth: lineLength, indent: 2 });
+    body = body.split('\n').map(line => `  ${line}`).join('\n');
     this.log(`---\n${this.#enhancer.objectInspect(body)}\n...`);
   }
 
@@ -59,16 +59,16 @@ export class TapEmitter implements TestConsumerShape {
    * Error to string
    * @param error
    */
-  errorToString(err?: Error): string | undefined {
-    if (err && err.name !== 'AssertionError') {
-      if (err instanceof Error) {
-        let out = JSON.stringify(hasToJSON(err) ? err.toJSON() : err, null, 2);
-        if (this.#options?.verbose && err.stack) {
-          out = `${out}\n${err.stack}`;
+  errorToString(error?: Error): string | undefined {
+    if (error && error.name !== 'AssertionError') {
+      if (error instanceof Error) {
+        let out = JSON.stringify(hasToJSON(error) ? error.toJSON() : error, null, 2);
+        if (this.#options?.verbose && error.stack) {
+          out = `${out}\n${error.stack}`;
         }
         return out;
       } else {
-        return `${err}`;
+        return `${error}`;
       }
     }
   }
@@ -76,9 +76,9 @@ export class TapEmitter implements TestConsumerShape {
   /**
    * Listen for each event
    */
-  onEvent(e: TestEvent): void {
-    if (e.type === 'test' && e.phase === 'after') {
-      const { test } = e;
+  onEvent(event: TestEvent): void {
+    if (event.type === 'test' && event.phase === 'after') {
+      const { test } = event;
       const suiteId = this.#enhancer.suiteName(test.classId);
       let header = `${suiteId} - ${this.#enhancer.testName(test.methodName)}`;
       if (test.description) {
@@ -155,8 +155,8 @@ export class TapEmitter implements TestConsumerShape {
 
     if (summary.errors.length) {
       this.log('---\n');
-      for (const err of summary.errors) {
-        const msg = this.errorToString(err);
+      for (const error of summary.errors) {
+        const msg = this.errorToString(error);
         if (msg) {
           this.log(this.#enhancer.failure(msg));
         }

package/src/consumer/types/xunit.ts

@@ -24,19 +24,19 @@ export class XunitEmitter implements TestConsumerShape {
   /**
    * Process metadata information (e.g. logs)
    */
-  buildMeta(obj: Record<string, unknown>): string {
-    if (!obj) {
+  buildMeta(meta: Record<string, unknown>): string {
+    if (!meta) {
       return '';
     }
 
-    for (const k of Object.keys(obj)) {
-      if (!obj[k]) {
-        delete obj[k];
+    for (const key of Object.keys(meta)) {
+      if (!meta[key]) {
+        delete meta[key];
       }
     }
-    if (Object.keys(obj).length) {
-      let body = stringify(obj);
-      body = body.split('\n').map(x => `  ${x}`).join('\n');
+    if (Object.keys(meta).length) {
+      let body = stringify(meta);
+      body = body.split('\n').map(line => `  ${line}`).join('\n');
       return `<![CDATA[\n${body}\n]]>`;
     } else {
       return '';
@@ -46,10 +46,10 @@ export class XunitEmitter implements TestConsumerShape {
   /**
    * Handle each test event
    */
-  onEvent(e: TestEvent): void {
-    if (e.type === 'test' && e.phase === 'after') {
+  onEvent(event: TestEvent): void {
+    if (event.type === 'test' && event.phase === 'after') {
 
-      const { test } = e;
+      const { test } = event;
 
       let name = `${test.methodName}`;
       if (test.description) {
@@ -59,8 +59,8 @@ export class XunitEmitter implements TestConsumerShape {
       let body = '';
 
       if (test.error) {
-        const assertErr = test.assertions.find(x => !!x.error)!;
-        body = `<failure type="${assertErr.text}" message="${encodeURIComponent(assertErr.message!)}"><![CDATA[${assertErr.error!.stack}]]></failure>`;
+        const assertion = test.assertions.find(item => !!item.error)!;
+        body = `<failure type="${assertion.text}" message="${encodeURIComponent(assertion.message!)}"><![CDATA[${assertion.error!.stack}]]></failure>`;
       }
 
       const groupedByLevel: Record<string, string[]> = {};
@@ -79,8 +79,8 @@ export class XunitEmitter implements TestConsumerShape {
       <system-err>${this.buildMeta({ error: groupedByLevel.error, warn: groupedByLevel.warn })}</system-err>
     </testcase>`
       );
-    } else if (e.type === 'suite' && e.phase === 'after') {
-      const { suite } = e;
+    } else if (event.type === 'suite' && event.phase === 'after') {
+      const { suite } = event;
       const testBodies = this.#tests.slice(0);
       this.#tests = [];
 

package/src/decorator/suite.ts

@@ -15,7 +15,7 @@ export function Suite(): ClassDecorator;
 export function Suite(...rest: Partial<SuiteConfig>[]): ClassDecorator;
 export function Suite(description: string, ...rest: Partial<SuiteConfig>[]): ClassDecorator;
 export function Suite(description?: string | Partial<SuiteConfig>, ...rest: Partial<SuiteConfig>[]): ClassDecorator {
-  const dec = (cls: Class): typeof cls => {
+  const decorator = (cls: Class): typeof cls => {
     const isAbstract = describeFunction(cls).abstract;
     SuiteRegistryIndex.getForRegister(cls).register(
       ...(typeof description !== 'string' && description ? [description] : []),
@@ -26,7 +26,7 @@ export function Suite(description?: string | Partial<SuiteConfig>, ...rest: Part
     return cls;
   };
 
-  return castTo(dec);
+  return castTo(decorator);
 }
 
 /**

package/src/decorator/test.ts

@@ -3,13 +3,15 @@ import { ClassInstance, getClass } from '@travetto/runtime';
 import { TestConfig, ThrowableError } from '../model/test.ts';
 import { SuiteRegistryIndex } from '../registry/registry-index.ts';
 
+type MethodDecorator = (instance: ClassInstance, property: string, descriptor: PropertyDescriptor) => PropertyDescriptor | void;
+
 /**
  * The `@AssertCheck` indicates that a function's assert calls should be transformed
  * @augments `@travetto/test:AssertCheck`
  * @kind decorator
  */
 export function AssertCheck(): MethodDecorator {
-  return (instance: ClassInstance, property: string | symbol, descriptor: PropertyDescriptor) => descriptor;
+  return (instance: ClassInstance, property: string, descriptor: PropertyDescriptor) => descriptor;
 }
 
 /**
@@ -24,7 +26,7 @@ export function Test(): MethodDecorator;
 export function Test(...rest: Partial<TestConfig>[]): MethodDecorator;
 export function Test(description: string, ...rest: Partial<TestConfig>[]): MethodDecorator;
 export function Test(description?: string | Partial<TestConfig>, ...rest: Partial<TestConfig>[]): MethodDecorator {
-  return (instance: ClassInstance, property: string | symbol, descriptor: PropertyDescriptor) => {
+  return (instance: ClassInstance, property: string, descriptor: PropertyDescriptor) => {
     SuiteRegistryIndex.getForRegister(getClass(instance)).registerTest(property, descriptor.value,
       ...(typeof description !== 'string' && description) ? [description] : [],
       ...rest,
@@ -40,7 +42,7 @@ export function Test(description?: string | Partial<TestConfig>, ...rest: Partia
  * @kind decorator
  */
 export function ShouldThrow(state: ThrowableError): MethodDecorator {
-  return (instance: ClassInstance, property: string | symbol, descriptor: PropertyDescriptor) => {
+  return (instance: ClassInstance, property: string, descriptor: PropertyDescriptor) => {
     SuiteRegistryIndex.getForRegister(getClass(instance)).registerTest(property, descriptor.value, { shouldThrow: state });
     return descriptor;
   };
@@ -52,7 +54,7 @@ export function ShouldThrow(state: ThrowableError): MethodDecorator {
  * @kind decorator
  */
 export function Timeout(ms: number): MethodDecorator {
-  return (instance: ClassInstance, property: string | symbol, descriptor: PropertyDescriptor) => {
+  return (instance: ClassInstance, property: string, descriptor: PropertyDescriptor) => {
     SuiteRegistryIndex.getForRegister(getClass(instance)).registerTest(property, descriptor.value, { timeout: ms });
     return descriptor;
   };

package/src/execute/barrier.ts

@@ -11,14 +11,14 @@ export class Barrier {
   /**
    * Track timeout
    */
-  static timeout(duration: number | TimeSpan, op: string = 'Operation'): { promise: Promise<void>, resolve: () => unknown } {
+  static timeout(duration: number | TimeSpan, operation: string = 'Operation'): { promise: Promise<void>, resolve: () => unknown } {
     const resolver = Promise.withResolvers<void>();
     const durationMs = TimeUtil.asMillis(duration);
     let timeout: NodeJS.Timeout;
     if (!durationMs) {
       resolver.resolve();
     } else {
-      const msg = `${op} timed out after ${duration}${typeof duration === 'number' ? 'ms' : ''}`;
+      const msg = `${operation} timed out after ${duration}${typeof duration === 'number' ? 'ms' : ''}`;
       timeout = setTimeout(() => resolver.reject(new TimeoutError(msg)), durationMs).unref();
     }
 
@@ -31,9 +31,9 @@ export class Barrier {
    */
   static uncaughtErrorPromise(): { promise: Promise<void>, resolve: () => unknown } {
     const uncaught = Promise.withResolvers<void>();
-    const onError = (err: Error): void => { Util.queueMacroTask().then(() => uncaught.reject(err)); };
-    UNCAUGHT_ERR_EVENTS.map(k => process.on(k, onError));
-    uncaught.promise.finally(() => { UNCAUGHT_ERR_EVENTS.map(k => process.off(k, onError)); });
+    const onError = (error: Error): void => { Util.queueMacroTask().then(() => uncaught.reject(error)); };
+    UNCAUGHT_ERR_EVENTS.map(key => process.on(key, onError));
+    uncaught.promise.finally(() => { UNCAUGHT_ERR_EVENTS.map(key => process.off(key, onError)); });
     return uncaught;
   }
 
@@ -80,7 +80,7 @@ export class Barrier {
   /**
    * Wait for operation to finish, with timeout and unhandled error support
    */
-  static async awaitOperation(timeout: number | TimeSpan, op: () => Promise<unknown>): Promise<Error | undefined> {
+  static async awaitOperation(timeout: number | TimeSpan, operation: () => Promise<unknown>): Promise<Error | undefined> {
     const uncaught = this.uncaughtErrorPromise();
     const timer = this.timeout(timeout);
     const promises = this.capturePromises();
@@ -88,9 +88,9 @@ export class Barrier {
     try {
       await promises.start();
       let capturedError: Error | undefined;
-      const opProm = op().then(() => promises.finish());
+      const opProm = operation().then(() => promises.finish());
 
-      await Promise.race([opProm, uncaught.promise, timer.promise]).catch(err => capturedError ??= err);
+      await Promise.race([opProm, uncaught.promise, timer.promise]).catch(error => capturedError ??= error);
 
       return capturedError;
     } finally {

package/src/execute/console.ts

@@ -22,7 +22,7 @@ export class ConsoleCapture implements ConsoleListener {
     this.out.push({
       ...rest,
       message: args
-        .map((x => typeof x === 'string' ? x : util.inspect(x, false, 5)))
+        .map((arg => typeof arg === 'string' ? arg : util.inspect(arg, false, 5)))
         .join(' ')
     });
   }

package/src/execute/executor.ts

@@ -15,7 +15,7 @@ import { Barrier } from './barrier.ts';
 import { ExecutionError } from './error.ts';
 import { SuiteRegistryIndex } from '../registry/registry-index.ts';
 
-const TEST_TIMEOUT = TimeUtil.fromValue(Env.TRV_TEST_TIMEOUT.val) ?? 5000;
+const TEST_TIMEOUT = TimeUtil.fromValue(Env.TRV_TEST_TIMEOUT.value) ?? 5000;
 
 /**
  * Support execution of the tests
@@ -73,8 +73,8 @@ export class TestExecutor {
   /**
    * Determining if we should skip
    */
-  async #shouldSkip(cfg: TestConfig | SuiteConfig, inst: unknown): Promise<boolean | undefined> {
-    if (typeof cfg.skip === 'function' ? await cfg.skip(inst) : cfg.skip) {
+  async #shouldSkip(config: TestConfig | SuiteConfig, inst: unknown): Promise<boolean | undefined> {
+    if (typeof config.skip === 'function' ? await config.skip(inst) : config.skip) {
       return true;
     }
   }
@@ -190,7 +190,7 @@ export class TestExecutor {
     // Mark suite start
     this.#consumer.onEvent({ phase: 'before', type: 'suite', suite });
 
-    const mgr = new TestPhaseManager(suite, result, e => this.#onSuiteFailure(e));
+    const mgr = new TestPhaseManager(suite, result, event => this.#onSuiteFailure(event));
 
     const originalEnv = { ...process.env };
 
@@ -226,8 +226,8 @@ export class TestExecutor {
 
       // Handle after all
       await mgr.endPhase('all');
-    } catch (err) {
-      await mgr.onError(err);
+    } catch (error) {
+      await mgr.onError(error);
     }
 
     // Restore env
@@ -246,12 +246,12 @@ export class TestExecutor {
   async execute(run: TestRun): Promise<void> {
     try {
       await Runtime.importFrom(run.import);
-    } catch (err) {
-      if (!(err instanceof Error)) {
-        throw err;
+    } catch (error) {
+      if (!(error instanceof Error)) {
+        throw error;
       }
-      console.error(err);
-      this.#onSuiteFailure(AssertUtil.gernerateImportFailure(run.import, err));
+      console.error(error);
+      this.#onSuiteFailure(AssertUtil.gernerateImportFailure(run.import, error));
       return;
     }
 

package/src/execute/phase.ts

@@ -8,7 +8,7 @@ class TestBreakout extends Error {
   source?: Error;
 }
 
-const TEST_PHASE_TIMEOUT = TimeUtil.fromValue(Env.TRV_TEST_PHASE_TIMEOUT.val) ?? 15000;
+const TEST_PHASE_TIMEOUT = TimeUtil.fromValue(Env.TRV_TEST_PHASE_TIMEOUT.value) ?? 15000;
 
 /**
  * Test Phase Execution Manager.
@@ -67,9 +67,9 @@ export class TestPhaseManager {
   /**
    * On error, handle stubbing out error for the phases in progress
    */
-  async onError(err: Error | unknown): Promise<void> {
-    if (!(err instanceof Error)) {
-      throw err;
+  async onError(error: Error | unknown): Promise<void> {
+    if (!(error instanceof Error)) {
+      throw error;
     }
 
     for (const ph of this.#progress) {
@@ -82,8 +82,8 @@ export class TestPhaseManager {
 
     const failure = AssertUtil.generateSuiteFailure(
       this.#suite,
-      err instanceof TestBreakout ? err.message : 'all',
-      err instanceof TestBreakout ? err.source! : err
+      error instanceof TestBreakout ? error.message : 'all',
+      error instanceof TestBreakout ? error.source! : error
     );
 
     this.#onSuiteFailure(failure);

package/src/execute/runner.ts

@@ -35,7 +35,7 @@ export class Runner {
 
     await consumer.onStart({ testCount: tests.length });
     await WorkPool.run(
-      f => buildStandardTestManager(consumer, f),
+      run => buildStandardTestManager(consumer, run),
       testRuns,
       {
         idleTimeoutMillis: TimeUtil.asMillis(10, 's'),
@@ -63,10 +63,10 @@ export class Runner {
     const target = await TestConsumerRegistryIndex.getInstance(this.#state);
 
     const consumer = new RunnableTestConsumer(target)
-      .withTransformer(e => {
+      .withTransformer(event => {
         // Copy run metadata to event
-        e.metadata = run.metadata;
-        return e;
+        event.metadata = run.metadata;
+        return event;
       });
 
     await consumer.onStart({});

package/src/execute/util.ts

@@ -40,17 +40,17 @@ export class RunnerUtil {
    */
   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'
+      module: mod => mod.roles.includes('test') || mod.roles.includes('std'),
+      folder: folder => folder === 'test',
+      file: file => file.role === 'test'
     });
 
     // Collect globs
     if (globs?.length) {
-      const allFiles = new Map(all.map(x => [x.sourceFile, x]));
+      const allFiles = new Map(all.map(file => [file.sourceFile, file]));
       for await (const item of fs.glob(globs)) {
-        const src = Runtime.workspaceRelative(path.resolve(item));
-        const match = allFiles.get(src);
+        const source = Runtime.workspaceRelative(path.resolve(item));
+        const match = allFiles.get(source);
         if (match && await this.isTestFile(match.sourceFile)) {
           yield match.import;
         }
@@ -96,12 +96,12 @@ export class RunnerUtil {
    * 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() });
+    const events = tests.reduce((runs, test) => {
+      if (!runs.has(test.classId)) {
+        runs.set(test.classId, { import: test.import, classId: test.classId, methodNames: [], runId: Util.uuid() });
       }
-      acc.get(test.classId)!.methodNames!.push(test.methodName);
-      return acc;
+      runs.get(test.classId)!.methodNames!.push(test.methodName);
+      return runs;
     }, new Map<string, TestRun>());
     return [...events.values()];
   }

package/src/execute/watcher.ts

@@ -32,15 +32,14 @@ export class TestWatcher {
       events.push(...RunnerUtil.getTestRuns(tests));
     }
 
-    const itr = new AsyncQueue(events);
+    const queue = new AsyncQueue(events);
     const consumer = new CumulativeSummaryConsumer(
       await TestConsumerRegistryIndex.getInstance({ consumer: format })
     )
-      .withFilter(x => x.metadata?.partial !== true || x.type !== 'suite');
+      .withFilter(event => event.metadata?.partial !== true || event.type !== 'suite');
 
     Registry.onMethodChange((event) => {
-      const [cls, method] = ('prev' in event && event.prev ? event.prev : null) ??
-        ('curr' in event && event.curr ? event.curr : []);
+      const [cls, method] = 'previous' in event ? event.previous : event.current;
 
       if (!cls || describeFunction(cls).abstract) {
         return;
@@ -52,14 +51,14 @@ export class TestWatcher {
         return;
       }
 
-      const conf = SuiteRegistryIndex.getTestConfig(cls, method)!;
+      const config = SuiteRegistryIndex.getTestConfig(cls, method)!;
       if (event.type !== 'removing') {
-        if (conf) {
+        if (config) {
           const run: TestRun = {
-            import: conf.import, classId: conf.classId, methodNames: [conf.methodName], metadata: { partial: true }
+            import: config.import, classId: config.classId, methodNames: [config.methodName], metadata: { partial: true }
           };
           console.log('Triggering', run);
-          itr.add(run, true); // Shift to front
+          queue.add(run, true); // Shift to front
         }
       } else {
         process.send?.({
@@ -73,17 +72,17 @@ export class TestWatcher {
     }, SuiteRegistryIndex);
 
     // If a file is changed, but doesn't emit classes, re-run whole file
-    Registry.onNonClassChanges(imp => itr.add({ import: imp }));
+    Registry.onNonClassChanges(imp => queue.add({ import: imp }));
 
-    process.on('message', ev => {
-      if (typeof ev === 'object' && ev && 'type' in ev && ev.type === 'run-test') {
-        console.log('Received message', ev);
+    process.on('message', event => {
+      if (typeof event === 'object' && event && 'type' in event && event.type === 'run-test') {
+        console.log('Received message', event);
         // Legacy
-        if ('file' in ev && typeof ev.file === 'string') {
-          ev = { import: RuntimeIndex.getFromSource(ev.file)?.import! };
+        if ('file' in event && typeof event.file === 'string') {
+          event = { import: RuntimeIndex.getFromSource(event.file)?.import! };
         }
-        console.debug('Manually triggered', ev);
-        itr.add(castTo(ev), true);
+        console.debug('Manually triggered', event);
+        queue.add(castTo(event), true);
       }
     });
 
@@ -91,7 +90,7 @@ export class TestWatcher {
 
     await WorkPool.run(
       buildStandardTestManager.bind(null, consumer),
-      itr,
+      queue,
       {
         idleTimeoutMillis: 120000,
         min: 2,

package/src/fixture.ts

@@ -5,8 +5,8 @@ export class TestFixtures extends FileLoader {
     super([
       '@#test/fixtures',
       '@#support/fixtures',
-      ...modules.flat().map(x => `${x}#support/fixtures`),
+      ...modules.flat().map(mod => `${mod}#support/fixtures`),
       '@@#support/fixtures'
-    ].map(v => Runtime.modulePath(v)));
+    ].map(value => Runtime.modulePath(value)));
   }
 }

package/src/model/suite.ts

@@ -22,7 +22,7 @@ export interface SuiteConfig extends SuiteCore {
   /**
    * Tests to run
    */
-  tests: Record<string | symbol, TestConfig>;
+  tests: Record<string, TestConfig>;
   /**
    * Before all handlers
    */

package/src/model/test.ts

@@ -2,7 +2,7 @@ import type { Class, ConsoleEvent, TimeSpan } from '@travetto/runtime';
 
 import { Skip, TestCore } from './common.ts';
 
-export type ThrowableError = string | RegExp | Class<Error> | ((e: Error | string) => boolean | void | undefined);
+export type ThrowableError = string | RegExp | Class<Error> | ((error: Error | string) => boolean | void | undefined);
 export type TestLog = Omit<ConsoleEvent, 'args' | 'scope'> & { message: string };
 
 /**

package/src/registry/registry-adapter.ts

@@ -6,24 +6,24 @@ import { SuiteConfig } from '../model/suite';
 import { TestConfig } from '../model/test';
 
 function combineClasses(baseConfig: SuiteConfig, ...subConfig: Partial<SuiteConfig>[]): SuiteConfig {
-  for (const cfg of subConfig) {
-    if (cfg.beforeAll) {
-      baseConfig.beforeAll = [...baseConfig.beforeAll, ...cfg.beforeAll];
+  for (const config of subConfig) {
+    if (config.beforeAll) {
+      baseConfig.beforeAll = [...baseConfig.beforeAll, ...config.beforeAll];
     }
-    if (cfg.beforeEach) {
-      baseConfig.beforeEach = [...baseConfig.beforeEach, ...cfg.beforeEach];
+    if (config.beforeEach) {
+      baseConfig.beforeEach = [...baseConfig.beforeEach, ...config.beforeEach];
     }
-    if (cfg.afterAll) {
-      baseConfig.afterAll = [...baseConfig.afterAll, ...cfg.afterAll];
+    if (config.afterAll) {
+      baseConfig.afterAll = [...baseConfig.afterAll, ...config.afterAll];
     }
-    if (cfg.afterEach) {
-      baseConfig.afterEach = [...baseConfig.afterEach, ...cfg.afterEach];
+    if (config.afterEach) {
+      baseConfig.afterEach = [...baseConfig.afterEach, ...config.afterEach];
     }
-    if (cfg.tags) {
-      baseConfig.tags = [...baseConfig.tags ?? [], ...cfg.tags];
+    if (config.tags) {
+      baseConfig.tags = [...baseConfig.tags ?? [], ...config.tags];
     }
-    if (cfg.tests) {
-      for (const [key, test] of Object.entries(cfg.tests ?? {})) {
+    if (config.tests) {
+      for (const [key, test] of Object.entries(config.tests ?? {})) {
         baseConfig.tests[key] = {
           ...test,
           sourceImport: Runtime.getImport(baseConfig.class),
@@ -40,11 +40,11 @@ function combineClasses(baseConfig: SuiteConfig, ...subConfig: Partial<SuiteConf
 function combineMethods(suite: SuiteConfig, baseConfig: TestConfig, ...subConfig: Partial<TestConfig>[]): TestConfig {
   baseConfig.classId = suite.classId;
   baseConfig.import = suite.import;
-  for (const cfg of subConfig) {
-    safeAssign(baseConfig, cfg, {
+  for (const config of subConfig) {
+    safeAssign(baseConfig, config, {
       tags: [
         ...baseConfig.tags ?? [],
-        ...cfg.tags ?? []
+        ...config.tags ?? []
       ]
     });
   }
@@ -80,7 +80,7 @@ export class SuiteRegistryAdapter implements RegistryAdapter<SuiteConfig> {
     return this.#config;
   }
 
-  registerTest(method: string | symbol, ...data: Partial<TestConfig>[]): TestConfig {
+  registerTest(method: string, ...data: Partial<TestConfig>[]): TestConfig {
     const suite = this.register();
 
     if (!(method in this.#config.tests)) {
@@ -92,7 +92,7 @@ export class SuiteRegistryAdapter implements RegistryAdapter<SuiteConfig> {
         lineStart: lines?.[0],
         lineEnd: lines?.[1],
         lineBodyStart: lines?.[2],
-        methodName: method.toString(),
+        methodName: method,
       });
       this.#config.tests[method] = config;
     }
@@ -109,7 +109,7 @@ export class SuiteRegistryAdapter implements RegistryAdapter<SuiteConfig> {
 
     for (const test of Object.values(this.#config.tests)) {
       test.tags = [...test.tags ?? [], ...this.#config.tags ?? []];
-      test.description ||= SchemaRegistryIndex.getMethodConfig(this.#cls, test.methodName).description;
+      test.description ||= SchemaRegistryIndex.get(this.#cls).getMethod(test.methodName).description;
     }
   }
 
@@ -117,7 +117,7 @@ export class SuiteRegistryAdapter implements RegistryAdapter<SuiteConfig> {
     return this.#config;
   }
 
-  getMethod(method: string | symbol): TestConfig {
+  getMethod(method: string): TestConfig {
     const test = this.#config.tests[method];
     if (!test) {
       throw new AppError(`Test not registered: ${String(method)} on ${this.#cls.name}`);