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

package/src/registry/registry-index.ts

@@ -5,8 +5,8 @@ import { SuiteConfig } from '../model/suite.ts';
 import { TestConfig, TestRun } from '../model/test.ts';
 import { SuiteRegistryAdapter } from './registry-adapter.ts';
 
-const sortedTests = (cfg: SuiteConfig): TestConfig[] =>
-  Object.values(cfg.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[] };
 
@@ -51,7 +51,7 @@ export class SuiteRegistryIndex implements RegistryIndex {
    * Find all valid tests (ignoring abstract)
    */
   getValidClasses(): Class[] {
-    return this.store.getClasses().filter(c => !describeFunction(c).abstract);
+    return this.store.getClasses().filter(cls => !describeFunction(cls).abstract);
   }
 
   getConfig(cls: Class): SuiteConfig {
@@ -70,27 +70,28 @@ export class SuiteRegistryIndex implements RegistryIndex {
       const line = parseInt(clsId, 10);
       const suites = this.getValidClasses()
         .filter(cls => Runtime.getImport(cls) === imp)
-        .map(x => this.getConfig(x)).filter(x => !x.skip);
-      const suite = suites.find(x => line >= x.lineStart && line <= x.lineEnd);
+        .map(cls => this.getConfig(cls))
+        .filter(config => !config.skip);
+      const suite = suites.find(config => line >= config.lineStart && line <= config.lineEnd);
 
       if (suite) {
         const tests = sortedTests(suite);
-        const test = tests.find(x => line >= x.lineStart && line <= x.lineEnd);
+        const test = tests.find(config => line >= config.lineStart && line <= config.lineEnd);
         return test ? [{ suite, tests: [test] }] : [{ suite, tests }];
       } else {
-        return suites.map(x => ({ suite: x, tests: sortedTests(x) }));
+        return suites.map(config => ({ suite: config, tests: sortedTests(config) }));
       }
     } else { // Else lookup directly
       if (methodNames.length) {
-        const cls = this.getValidClasses().find(x => x.Ⲑid === clsId);
+        const cls = this.getValidClasses().find(type => type.Ⲑid === clsId);
         if (!cls) {
           throw new AppError('Unable to find suite for class ID', { details: { classId: clsId } });
         }
         const suite = this.getConfig(cls);
-        const tests = sortedTests(suite).filter(x => methodNames.includes(x.methodName));
+        const tests = sortedTests(suite).filter(config => methodNames.includes(config.methodName));
         return [{ suite, tests }];
       } else if (clsId) {
-        const cls = this.getValidClasses().find(x => x.Ⲑid === clsId)!;
+        const cls = this.getValidClasses().find(type => type.Ⲑid === clsId)!;
         if (!cls) {
           throw new AppError('Unable to find suite for class ID', { details: { classId: clsId } });
         }
@@ -98,9 +99,9 @@ export class SuiteRegistryIndex implements RegistryIndex {
         return suite ? [{ suite, tests: sortedTests(suite) }] : [];
       } else {
         const suites = this.getValidClasses()
-          .map(x => this.getConfig(x))
-          .filter(x => !describeFunction(x.class).abstract);  // Do not run abstract suites
-        return suites.map(x => ({ suite: x, tests: sortedTests(x) }));
+          .map(type => this.getConfig(type))
+          .filter(config => !describeFunction(config.class).abstract);  // Do not run abstract suites
+        return suites.map(config => ({ suite: config, tests: sortedTests(config) }));
       }
     }
   }
@@ -110,8 +111,8 @@ export class SuiteRegistryIndex implements RegistryIndex {
    */
   getTestConfig(cls: Class, method: Function): TestConfig | undefined {
     if (this.store.has(cls)) {
-      const conf = this.getConfig(cls);
-      return Object.values(conf.tests).find(x => x.methodName === method.name);
+      const config = this.getConfig(cls);
+      return Object.values(config.tests).find(item => item.methodName === method.name);
     }
   }
 }

package/src/worker/child.ts

@@ -16,16 +16,16 @@ export class TestChildWorker extends IpcChannel<TestRun> {
 
   #done = Promise.withResolvers<void>();
 
-  async #exec(op: () => Promise<unknown>, type: string): Promise<void> {
+  async #exec(operation: () => Promise<unknown>, type: string): Promise<void> {
     try {
-      await op();
+      await operation();
       this.send(type); // Respond
-    } catch (err) {
-      if (!(err instanceof Error)) {
-        throw err;
+    } catch (error) {
+      if (!(error instanceof Error)) {
+        throw error;
       }
       // Mark as errored out
-      this.send(type, JSON.parse(Util.serializeToJSON({ error: err })));
+      this.send(type, JSON.parse(Util.serializeToJSON({ error })));
     }
   }
 
@@ -33,11 +33,11 @@ export class TestChildWorker extends IpcChannel<TestRun> {
    * Start the worker
    */
   async activate(): Promise<void> {
-    if (/\b@travetto[/]test\b/.test(Env.DEBUG.val ?? '')) {
+    if (/\b@travetto[/]test\b/.test(Env.DEBUG.value ?? '')) {
       const file = Runtime.toolPath(`test-worker.${process.pid}.log`);
       const stdout = createWriteStream(file, { flags: 'a' });
-      const c = new console.Console({ stdout, inspectOptions: { depth: 4, colors: false } });
-      ConsoleManager.set({ log: (ev) => c[ev.level](process.pid, ...ev.args) });
+      const cons = new console.Console({ stdout, inspectOptions: { depth: 4, colors: false } });
+      ConsoleManager.set({ log: (event) => cons[event.level](process.pid, ...event.args) });
     } else {
       ConsoleManager.set({ log: () => { } });
     }
@@ -45,7 +45,7 @@ export class TestChildWorker extends IpcChannel<TestRun> {
     RunnerUtil.registerCleanup('worker');
 
     // Listen for inbound requests
-    this.on('*', ev => this.onCommand(ev));
+    this.on('*', event => this.onCommand(event));
 
     // Let parent know the child is ready for handling commands
     this.send(Events.READY);

package/src/worker/standard.ts

@@ -41,9 +41,9 @@ export async function buildStandardTestManager(consumer: TestConsumerShape, run:
   await channel.send(Events.INIT); // Initialize
   await channel.once(Events.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
+      await consumer.onEvent(Util.deserializeFromJson(JSON.stringify(event)));  // Connect the consumer with the event stream from the child
     } catch {
       // Do nothing
     }
@@ -55,7 +55,7 @@ export async function buildStandardTestManager(consumer: TestConsumerShape, run:
   channel.send(Events.RUN, run);
 
   // Wait for complete
-  const result = await complete.then(ev => Util.deserializeFromJson<typeof ev>(JSON.stringify(ev)));
+  const result = await complete.then(event => Util.deserializeFromJson<typeof event>(JSON.stringify(event)));
 
   // Kill on complete
   await channel.destroy();

package/support/bin/run.ts

@@ -6,19 +6,19 @@ import type { RunState } from '../../src/execute/types.ts';
 
 /**
  * Run tests given the input state
- * @param opts
+ * @param state
  */
-export async function runTests(opts: RunState): Promise<void> {
+export async function runTests(state: RunState): Promise<void> {
   const { RunnerUtil } = await import('../../src/execute/util.ts');
   const { Runner } = await import('../../src/execute/runner.ts');
 
   RunnerUtil.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 new Runner(state).run();
+    process.exitCode = result ? 0 : 1;
+  } catch (error) {
+    console.error('Test Worker Failed', { error });
     process.exitCode = 1;
   }
 }

package/support/cli.test.ts

@@ -45,7 +45,7 @@ export class TestCommand implements CliCommandShape {
   }
 
   isFirstFile(first: string): Promise<boolean> {
-    return fs.stat(path.resolve(first ?? '')).then(x => x.isFile(), () => false);
+    return fs.stat(path.resolve(first ?? '')).then(stat => stat.isFile(), () => false);
   }
 
   async resolvedMode(first: string, rest: string[]): Promise<string> {
@@ -70,7 +70,7 @@ export class TestCommand implements CliCommandShape {
 
     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]));
+    const options = Object.fromEntries((this.formatOptions ?? [])?.map(option => [...option.split(':'), true]));
 
     return runTests({
       concurrency: this.concurrency,

package/support/cli.test_digest.ts

@@ -22,8 +22,8 @@ export class TestDigestCommand {
     for await (const imp of await RunnerUtil.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

@@ -31,7 +31,7 @@ export class TestDirectCommand {
 
   main(importOrFile: string, clsId?: string, methodsNames: string[] = []): Promise<void> {
 
-    const options = Object.fromEntries((this.formatOptions ?? [])?.map(f => [...f.split(':'), true]));
+    const options = Object.fromEntries((this.formatOptions ?? [])?.map(option => [...option.split(':'), true]));
 
     return runTests({
       consumer: this.format,

package/support/cli.test_watch.ts

@@ -29,8 +29,8 @@ export class TestWatcherCommand {
     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() });