@travetto/test 8.0.0-alpha.9 → 8.0.0

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/trv.d.ts

@@ -1,4 +1,4 @@
-import { TimeSpan } from '@travetto/runtime';
+import type { TimeSpan } from '@travetto/runtime';
 
 declare module '@travetto/runtime' {
   interface EnvData {
@@ -17,4 +17,4 @@ declare module '@travetto/runtime' {
      */
     TRV_TEST_TAGS: string[];
   }
-}
+}

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();
     }
   }
-}
+}

package/src/worker/standard.ts

@@ -1,12 +1,12 @@
 import { fork } from 'node:child_process';
 
-import { JSONUtil, Env, RuntimeIndex } from '@travetto/runtime';
+import { Env, JSONUtil, RuntimeIndex } from '@travetto/runtime';
 import { IpcChannel } from '@travetto/worker';
 
-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 { type TestLogEvent, TestWorkerEvents } from './types.ts';
 
 const log = (message: string | TestLogEvent): void => {
   const event: TestLogEvent = typeof message === 'string' ? { type: 'log', message } : message;
@@ -20,16 +20,13 @@ export async function buildStandardTestManager(consumer: TestConsumerShape, run:
   log(`Worker Input ${JSONUtil.toUTF8(run)}`);
 
   const channel = new IpcChannel<TestEvent & { error?: Error }>(
-    fork(
-      RuntimeIndex.resolveFileImport('@travetto/cli/support/entry.trv.ts'), ['test:child'],
-      {
-        env: {
-          ...process.env,
-          ...Env.TRV_QUIET.export(true)
-        },
-        stdio: ['ignore', 'ignore', 2, 'ipc']
-      }
-    )
+    fork(RuntimeIndex.resolveFileImport('@travetto/cli/support/entry.trv.ts'), ['test:child'], {
+      env: {
+        ...process.env,
+        ...Env.TRV_QUIET.export(true)
+      },
+      stdio: ['ignore', 'ignore', 2, 'ipc']
+    })
   );
 
   await channel.once(TestWorkerEvents.READY); // Wait for the child to be ready
@@ -45,7 +42,7 @@ export async function buildStandardTestManager(consumer: TestConsumerShape, run:
         log(`Received remove event ${JSONUtil.toUTF8(event)}@${consumer.constructor.name}`);
         consumer.onRemoveEvent?.(parsed); // Forward remove events
       } else {
-        consumer.onEvent(parsed);  // Forward standard events
+        consumer.onEvent(parsed); // Forward standard events
       }
     } catch {
       // Do nothing
@@ -70,4 +67,4 @@ export async function buildStandardTestManager(consumer: TestConsumerShape, run:
   if (result.error) {
     throw result.error;
   }
-}
+}

package/src/worker/types.ts

@@ -11,16 +11,12 @@ export const TestWorkerEvents = {
   READY: 'ready'
 };
 
-export type TestRunEvent = { type: 'runTest', import: string };
+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 TestLogEvent = { type: 'log'; message: string };
 
-export type TestWatchEvent =
-  TestEvent |
-  TestRemoveEvent |
-  TestReadyEvent |
-  TestLogEvent;
+export type TestWatchEvent = TestEvent | TestRemoveEvent | TestReadyEvent | TestLogEvent;

package/support/bin/run.ts

@@ -17,4 +17,4 @@ export async function runTests(state: TestConsumerConfig, input: TestRunInput):
   }
 }
 
-export type TestConsumerType = 'tap' | 'tap-summary' | 'json' | 'exec' | 'event' | 'xunit' | 'custom';
+export type TestConsumerType = 'tap' | 'tap-summary' | 'json' | 'exec' | 'event' | 'xunit' | 'custom';

package/support/cli.test.ts

@@ -1,23 +1,26 @@
 import { EventEmitter } from 'node:events';
 
+import { CliCommand, type CliCommandShape, CliUtil } from '@travetto/cli';
 import { Env, RuntimeIndex } from '@travetto/runtime';
-import { type CliCommandShape, CliCommand, CliUtil } from '@travetto/cli';
-import { WorkPool } from '@travetto/worker';
 import { Max, Min } from '@travetto/schema';
+import { WorkPool } from '@travetto/worker';
 
 import type { TestConsumerType } from './bin/run.ts';
 
 /**
- * Launch test framework and execute tests
+ * Execute the test framework for targeted files, suites, or methods.
+ *
+ * Supports glob-based discovery, import-based targeting, tag filtering, and
+ * configurable output consumers for local and CI workflows.
  */
 @CliCommand()
 export class TestCommand implements CliCommandShape {
-
   /** Output format for test results */
   format: TestConsumerType = 'tap';
 
   /** Number of tests to run concurrently */
-  @Min(1) @Max(WorkPool.MAX_SIZE)
+  @Min(1)
+  @Max(WorkPool.MAX_SIZE)
   concurrency: number = WorkPool.DEFAULT_SIZE;
 
   /**
@@ -49,16 +52,18 @@ export class TestCommand implements CliCommandShape {
       {
         concurrency: this.concurrency,
         consumer: this.format,
-        consumerOptions: CliUtil.readExtendedOptions(this.formatOptions),
+        consumerOptions: CliUtil.readExtendedOptions(this.formatOptions)
       },
-      importPath ? {
-        import: importPath,
-        classId: globs[0],
-        methodNames: globs.slice(1),
-      } : {
-        globs: [first, ...globs],
-        tags: this.tags,
-      }
+      importPath
+        ? {
+            import: importPath,
+            classId: globs[0],
+            methodNames: globs.slice(1)
+          }
+        : {
+            globs: [first, ...globs],
+            tags: this.tags
+          }
     );
   }
-}
+}

package/support/cli.test_child.ts

@@ -1,10 +1,15 @@
 import { EventEmitter } from 'node:events';
 
-import { Env } from '@travetto/runtime';
 import { CliCommand } from '@travetto/cli';
+import { Env } from '@travetto/runtime';
 import { IsPrivate } from '@travetto/schema';
 
-/** Test child worker target */
+/**
+ * Internal command target for test child workers.
+ *
+ * Used by the test runner to bootstrap isolated worker processes with test-
+ * oriented runtime configuration.
+ */
 @CliCommand()
 @IsPrivate()
 export class TestChildWorkerCommand {
@@ -22,4 +27,4 @@ export class TestChildWorkerCommand {
     const { TestChildWorker } = await import('../src/worker/child.ts');
     return new TestChildWorker().activate();
   }
-}
+}

package/support/cli.test_diff.ts

@@ -1,17 +1,21 @@
 import fs from 'node:fs/promises';
 
-import { Env, JSONUtil, RuntimeIndex } from '@travetto/runtime';
 import { CliCommand, CliUtil } from '@travetto/cli';
+import { Env, JSONUtil, RuntimeIndex } from '@travetto/runtime';
 import { IsPrivate } from '@travetto/schema';
 
-import { runTests, type TestConsumerType } from './bin/run.ts';
 import type { TestDiffSource } from '../src/model/test.ts';
+import { runTests, type TestConsumerType } from './bin/run.ts';
 
-/**  Direct test invocation */
+/**
+ * Run tests scoped by a precomputed diff source file.
+ *
+ * The first argument resolves the test import root, and the second argument is
+ * a JSON diff payload consumed by test-selection logic.
+ */
 @CliCommand()
 @IsPrivate()
 export class TestDiffCommand {
-
   /** Output format for test results */
   format: TestConsumerType = 'tap';
 
@@ -29,12 +33,12 @@ export class TestDiffCommand {
 
   async main(importOrFile: string, diff: string): Promise<void> {
     const diffSource = await fs.readFile(diff).then(JSONUtil.fromBinaryArray<TestDiffSource>);
-    const importPath = RuntimeIndex.getFromImportOrSource(importOrFile)?.import!;
+    const importPath = RuntimeIndex.getFromImportOrSource(importOrFile)!.import;
 
     return runTests(
       {
         consumer: this.format,
-        consumerOptions: CliUtil.readExtendedOptions(this.formatOptions),
+        consumerOptions: CliUtil.readExtendedOptions(this.formatOptions)
       },
       {
         import: importPath,
@@ -42,4 +46,4 @@ export class TestDiffCommand {
       }
     );
   }
-}
+}

package/support/cli.test_digest.ts

@@ -1,15 +1,21 @@
 import { CliCommand } from '@travetto/cli';
-import { JSONUtil, Env, Runtime, describeFunction } from '@travetto/runtime';
 import { Registry } from '@travetto/registry';
+import { describeFunction, Env, JSONUtil, Runtime } from '@travetto/runtime';
 import { IsPrivate } from '@travetto/schema';
 
-import { SuiteRegistryIndex } from '../src/registry/registry-index.ts';
 import { RunUtil } from '../src/execute/run.ts';
+import { SuiteRegistryIndex } from '../src/registry/registry-index.ts';
 
 @CliCommand()
 @IsPrivate()
+/**
+ * Produce a deterministic digest of discovered test identifiers.
+ *
+ * This is an internal command used by tooling to enumerate tests in a stable
+ * order for planning, sharding, or change detection workflows.
+ */
 export class TestDigestCommand {
-
+  /** Output mode for digest emission. */
   output: 'json' | 'text' = 'text';
 
   preMain(): void {
@@ -47,4 +53,4 @@ export class TestDigestCommand {
       }
     }
   }
-}
+}

package/support/cli.test_direct.ts

@@ -1,14 +1,18 @@
-import { Env, RuntimeIndex } from '@travetto/runtime';
 import { CliCommand, CliUtil } from '@travetto/cli';
+import { Env, RuntimeIndex } from '@travetto/runtime';
 import { IsPrivate } from '@travetto/schema';
 
 import { runTests, type TestConsumerType } from './bin/run.ts';
 
-/**  Direct test invocation */
+/**
+ * Run tests directly from an import or source file with optional class/method filtering.
+ *
+ * This internal command bypasses discovery by targeting a specific test import
+ * and optional class or method names.
+ */
 @CliCommand()
 @IsPrivate()
 export class TestDirectCommand {
-
   /** Output format for test results */
   format: TestConsumerType = 'tap';
 
@@ -26,18 +30,18 @@ export class TestDirectCommand {
 
   main(importOrFile: string, clsId?: string, methodsNames: string[] = []): Promise<void> {
     // Resolve to import
-    const importPath = RuntimeIndex.getFromImportOrSource(importOrFile)?.import!;
+    const importPath = RuntimeIndex.getFromImportOrSource(importOrFile)!.import;
 
     return runTests(
       {
         consumer: this.format,
-        consumerOptions: CliUtil.readExtendedOptions(this.formatOptions),
+        consumerOptions: CliUtil.readExtendedOptions(this.formatOptions)
       },
       {
         import: importPath,
         classId: clsId,
-        methodNames: methodsNames,
+        methodNames: methodsNames
       }
     );
   }
-}
+}

package/support/cli.test_watch.ts

@@ -1,14 +1,16 @@
-import { Env } from '@travetto/runtime';
 import { CliCommand } from '@travetto/cli';
+import { Env } from '@travetto/runtime';
 
 import type { TestConsumerType } from './bin/run.ts';
 
 /**
- * Invoke the test watcher
+ * Start the test watcher for continuous test execution.
+ *
+ * Watches project changes and reruns either all tests or changed subsets,
+ * using the configured output format.
  */
 @CliCommand()
 export class TestWatcherCommand {
-
   /** Output format for test results */
   format: TestConsumerType = 'tap';
 
@@ -26,4 +28,4 @@ export class TestWatcherCommand {
       console.error(error);
     }
   }
-}
+}

package/support/transformer.assert.ts

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 
-import { type TransformerState, DeclarationUtil, CoreUtil, TransformerHandler } from '@travetto/transformer';
+import { CoreUtil, DeclarationUtil, TransformerHandler, type TransformerState } from '@travetto/transformer';
 
 /**
  * Which types are candidates for deep literal checking
@@ -18,9 +18,9 @@ export const DEEP_EQUALS_MAPPING: Record<string, string> = {
 };
 
 /**
- * Typescript optoken to assert methods
+ * Typescript op token to assert methods
  */
-export const OPTOKEN_ASSERT = {
+export const OP_TOKEN_ASSERT = {
   InKeyword: 'in',
   EqualsEqualsToken: 'equal',
   ExclamationEqualsToken: 'notEqual',
@@ -46,7 +46,7 @@ const METHODS: Record<string, Function[]> = {
   test: [RegExp]
 };
 
-const OP_TOKEN_TO_NAME = new Map<number, keyof typeof OPTOKEN_ASSERT>();
+const OP_TOKEN_TO_NAME = new Map<number, keyof typeof OP_TOKEN_ASSERT>();
 
 const AssertSymbol = Symbol();
 const IsTestSymbol = Symbol();
@@ -89,7 +89,6 @@ interface Command {
  * and result generation
  */
 export class AssertTransformer {
-
   static {
     TransformerHandler(this, this.onAssertCheck, 'before', 'method', ['AssertCheck']);
     TransformerHandler(this, this.afterAssertCheck, 'after', 'method', ['AssertCheck']);
@@ -97,20 +96,21 @@ export class AssertTransformer {
   }
 
   /**
-   * Resolves optoken to syntax kind.  Relies on `ts`
+   * Resolves op token to syntax kind.  Relies on `ts`
    */
   static lookupOpToken(key: number): string | undefined {
     if (OP_TOKEN_TO_NAME.size === 0) {
       Object.keys(ts.SyntaxKind)
         .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));
+        .filter((kind): kind is keyof typeof OP_TOKEN_ASSERT => !/^(Last|First)/.test(kind))
+        .forEach(kind => {
+          OP_TOKEN_TO_NAME.set(ts.SyntaxKind[kind], kind);
+        });
     }
 
     const name = OP_TOKEN_TO_NAME.get(key)!;
-    if (name in OPTOKEN_ASSERT) {
-      return OPTOKEN_ASSERT[name];
+    if (name in OP_TOKEN_ASSERT) {
+      return OP_TOKEN_ASSERT[name];
     } else {
       return;
     }
@@ -120,19 +120,18 @@ export class AssertTransformer {
    * Determine if element is a deep literal (should use deep comparison)
    */
   static isDeepLiteral(state: TransformerState, node: ts.Expression): boolean {
-    let found = ts.isArrayLiteralExpression(node) ||
+    let found =
+      ts.isArrayLiteralExpression(node) ||
       ts.isObjectLiteralExpression(node) ||
-      (
-        ts.isNewExpression(node) &&
-        DEEP_LITERAL_TYPES.has(node.expression.getText())
-      );
+      (ts.isNewExpression(node) && DEEP_LITERAL_TYPES.has(node.expression.getText()));
 
     // 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(declaration =>
-        // In a separate file or is const
-        declaration.getSourceFile().fileName !== state.source.fileName ||
-        DeclarationUtil.isConstantDeclaration(declaration));
+      found = !!state.getDeclarations(node).find(
+        declaration =>
+          // In a separate file or is const
+          declaration.getSourceFile().fileName !== state.source.fileName || DeclarationUtil.isConstantDeclaration(declaration)
+      );
     }
 
     return found;
@@ -143,12 +142,12 @@ export class AssertTransformer {
    */
   static initState(state: TransformerState & AssertState): void {
     if (!state[AssertSymbol]) {
-      const asrt = state.importFile('@travetto/test/src/assert/check.ts').identifier;
+      const assertion = state.importFile('@travetto/test/src/assert/check.ts').identifier;
       state[AssertSymbol] = {
-        assert: asrt,
-        assertCheck: CoreUtil.createAccess(state.factory, asrt, ASSERT_UTIL, 'check'),
-        checkThrow: CoreUtil.createAccess(state.factory, asrt, ASSERT_UTIL, 'checkThrow'),
-        checkThrowAsync: CoreUtil.createAccess(state.factory, asrt, ASSERT_UTIL, 'checkThrowAsync'),
+        assert: assertion,
+        assertCheck: CoreUtil.createAccess(state.factory, assertion, ASSERT_UTIL, 'check'),
+        checkThrow: CoreUtil.createAccess(state.factory, assertion, ASSERT_UTIL, 'checkThrow'),
+        checkThrowAsync: CoreUtil.createAccess(state.factory, assertion, ASSERT_UTIL, 'checkThrowAsync')
       };
     }
   }
@@ -163,16 +162,20 @@ export class AssertTransformer {
     const firstText = first?.getText() ?? node.getText();
 
     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(),
-        line: state.fromLiteral(ts.getLineAndCharacterOfPosition(state.source, node.getStart()).line + 1),
-        text: state.fromLiteral(firstText),
-        operator: state.fromLiteral(cmd.fn)
-      }),
-      state.fromLiteral(!cmd.negate),
-      ...cmd.args
-    ]));
+    const check = state.factory.createCallExpression(
+      state[AssertSymbol]!.assertCheck,
+      undefined,
+      state.factory.createNodeArray([
+        state.fromLiteral({
+          module: state.getModuleIdentifier(),
+          line: state.fromLiteral(ts.getLineAndCharacterOfPosition(state.source, node.getStart()).line + 1),
+          text: state.fromLiteral(firstText),
+          operator: state.fromLiteral(cmd.fn)
+        }),
+        state.fromLiteral(!cmd.negate),
+        ...cmd.args
+      ])
+    );
 
     return check;
   }
@@ -197,7 +200,8 @@ export class AssertTransformer {
         }),
         state.fromLiteral(key.startsWith('doesNot')),
         ...args
-      ]));
+      ])
+    );
   }
 
   /**
@@ -234,7 +238,6 @@ export class AssertTransformer {
    * Check various `assert.*` method calls
    */
   static doMethodCall(state: TransformerState, comp: ts.Expression, args: Args): Command {
-
     if (ts.isCallExpression(comp) && ts.isPropertyAccessExpression(comp.expression)) {
       const root = comp.expression.expression;
       const key = comp.expression.name;
@@ -242,10 +245,13 @@ export class AssertTransformer {
       const matched = METHODS[key.text!];
       if (matched) {
         const resolved = state.resolveType(root);
-        if (resolved.key === 'literal' && matched.find(type => resolved.ctor === type)) { // 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)] };
+            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)] };
           }
         }
       }
@@ -294,13 +300,15 @@ export class AssertTransformer {
     const exp = node.expression;
 
     // Determine if calling assert directly
-    if (ts.isIdentifier(exp) && exp.getSourceFile() && exp.getText() === ASSERT_CMD) { // Straight assert
+    if (ts.isIdentifier(exp) && exp.getSourceFile() && exp.getText() === ASSERT_CMD) {
+      // Straight assert
       const cmd = this.getCommand(state, node.arguments);
       if (cmd) {
         node = this.doAssert(state, node, cmd);
       }
       // If calling `assert.*`
-    } else if (ts.isPropertyAccessExpression(exp) && ts.isIdentifier(exp.expression)) { // Assert method call
+    } else if (ts.isPropertyAccessExpression(exp) && ts.isIdentifier(exp.expression)) {
+      // Assert method call
       const identifier = exp.expression;
       const fn = exp.name.escapedText.toString();
       if (identifier.escapedText === ASSERT_CMD) {
@@ -318,4 +326,4 @@ export class AssertTransformer {
 
     return node;
   }
-}
+}