@travetto/test 2.1.4 → 2.2.1

package/src/registry/suite.ts

@@ -12,7 +12,7 @@ class $SuiteRegistry extends MetadataRegistry<SuiteConfig, TestConfig> {
   /**
    * Find all valid tests (ignoring abstract)
    */
-  getValidClasses() {
+  getValidClasses(): Class[] {
     return this.getClasses().filter(c => !c.ᚕabstract);
   }
 
@@ -29,7 +29,7 @@ class $SuiteRegistry extends MetadataRegistry<SuiteConfig, TestConfig> {
     };
   }
 
-  override createPendingField(cls: Class, fn: Function) {
+  override createPendingField(cls: Class, fn: Function): Partial<TestConfig> {
     return {
       class: cls,
       file: cls.ᚕfile,
@@ -40,9 +40,9 @@ class $SuiteRegistry extends MetadataRegistry<SuiteConfig, TestConfig> {
   /**
    * Add a new phase listeners
    */
-  registerPendingListener<T>(cls: Class<T>, listener: Function, phase: 'beforeAll' | 'beforeEach' | 'afterAll' | 'afterEach') {
-    const suiteConfig = this.getOrCreatePending(cls)! as SuiteConfig;
-    suiteConfig[phase].push(listener);
+  registerPendingListener<T>(cls: Class<T>, listener: Function, phase: 'beforeAll' | 'beforeEach' | 'afterAll' | 'afterEach'): void {
+    const suiteConfig = this.getOrCreatePending(cls);
+    suiteConfig[phase]!.push(listener);
   }
 
   /**
@@ -50,24 +50,27 @@ class $SuiteRegistry extends MetadataRegistry<SuiteConfig, TestConfig> {
    * a full projection of all listeners and tests.
    */
   onInstallFinalize<T>(cls: Class<T>): SuiteConfig {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const config = this.getOrCreatePending(cls) as SuiteConfig;
     const tests = [...this.pendingFields.get(cls.ᚕid)!.values()];
 
     const parent = this.getParentClass(cls);
 
     if (parent && this.has(parent)) {
-      const pconf = this.get(parent);
-      config.afterAll.push(...pconf.afterAll);
-      config.beforeAll.push(...pconf.beforeAll);
-      config.afterEach.push(...pconf.afterEach);
-      config.beforeEach.push(...pconf.beforeEach);
-      tests.push(...[...pconf.tests.values()].map(t => ({
+      const pConf = this.get(parent);
+      config.afterAll.push(...pConf.afterAll);
+      config.beforeAll.push(...pConf.beforeAll);
+      config.afterEach.push(...pConf.afterEach);
+      config.beforeEach.push(...pConf.beforeEach);
+      tests.push(...[...pConf.tests.values()].map(t => ({
         ...t,
         class: cls
       })));
     }
 
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     config.instance = new (config.class as ConcreteClass)();
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     config.tests = tests as TestConfig[];
 
     if (!config.description) {
@@ -116,7 +119,7 @@ class $SuiteRegistry extends MetadataRegistry<SuiteConfig, TestConfig> {
   /**
    * Find a test configuration given class and optionally a method
    */
-  getByClassAndMethod(cls: Class, method: Function) {
+  getByClassAndMethod(cls: Class, method: Function): TestConfig | undefined {
     if (this.has(cls)) {
       const conf = this.get(cls);
       return conf.tests.find(x => x.methodName === method.name);

package/src/worker/child.ts

@@ -11,10 +11,10 @@ const FIXED_MODULES = new Set([
   // 'registry'
   'boot', 'base', 'cli',
   'compiler', 'transformer',
-  'yaml','worker', 'command',
+  'yaml', 'worker', 'command',
   'log', 'jwt', 'image',
   'test',
-].map(x => `@travetto/${x}` as string));
+].map(x => `@travetto/${x}`));
 
 /**
  * Child Worker for the Test Runner.  Receives events as commands
@@ -24,20 +24,23 @@ export class TestChildWorker extends ChildCommChannel<RunEvent> {
 
   #runs = 0;
 
-  async #exec(op: () => Promise<unknown>, type: string) {
+  async #exec(op: () => Promise<unknown>, type: string): Promise<void> {
     try {
       await op();
       this.send(type); // Respond
-    } catch (e) {
+    } catch (err) {
+      if (!(err instanceof Error)) {
+        throw err;
+      }
       // Mark as errored out
-      this.send(type, { error: ErrorUtil.serializeError(e) });
+      this.send(type, { error: ErrorUtil.serializeError(err) });
     }
   }
 
   /**
    * Start the worker
    */
-  async activate() {
+  async activate(): Promise<void> {
     const { RunnerUtil } = await import('../execute/util');
     RunnerUtil.registerCleanup('worker');
 
@@ -51,7 +54,7 @@ export class TestChildWorker extends ChildCommChannel<RunEvent> {
   /**
    * When we receive a command from the parent
    */
-  async onCommand(event: RunEvent & { type: string }) {
+  async onCommand(event: RunEvent & { type: string }): Promise<boolean> {
     console.debug('on message', { ...event });
 
     if (event.type === Events.INIT) { // On request to init, start initialization
@@ -66,12 +69,12 @@ export class TestChildWorker extends ChildCommChannel<RunEvent> {
   /**
    * In response to the initialization command
    */
-  async onInitCommand() { }
+  async onInitCommand(): Promise<void> { }
 
   /**
    * Reset the state to prepare for the next run
    */
-  async resetForRun() {
+  async resetForRun(): Promise<void> {
     // Clear require cache of all data loaded minus base framework pieces
     console.debug('Resetting', { fileCount: Object.keys(require.cache).length });
 
@@ -95,7 +98,7 @@ export class TestChildWorker extends ChildCommChannel<RunEvent> {
   /**
    * Run a specific test/suite
    */
-  async onRunCommand(event: RunEvent) {
+  async onRunCommand(event: RunEvent): Promise<void> {
     this.#runs += 1;
     console.debug('Run');
 

package/src/worker/isolated.ts

@@ -6,13 +6,13 @@ import { TestExecutor } from '../execute/executor';
 /**
  *  Produce a handler for the child worker
  */
-export function buildIsolatedTestManager(consumer: TestConsumer) {
+export function buildIsolatedTestManager(consumer: TestConsumer): () => Worker<string> {
   let id = 0;
   return (): Worker<string> => ({
     id: id++,
     active: true,
-    async destroy() { },
-    async execute(file: string) {
+    async destroy(): Promise<void> { },
+    async execute(file: string): Promise<void> {
       await TestExecutor.executeIsolated(consumer, file);
     }
   });

package/src/worker/standard.ts

@@ -1,16 +1,15 @@
 import { ErrorUtil } from '@travetto/base/src/internal/error';
-import { ParentCommChannel, WorkUtil } from '@travetto/worker';
+import { ParentCommChannel, Worker, WorkUtil } from '@travetto/worker';
 import { AppCache, ExecUtil } from '@travetto/boot';
 
 import { Events, RunEvent } from './types';
 import { TestConsumer } from '../consumer/types';
 import { TestEvent } from '../model/event';
-import { TestResult } from '../model/test';
 
 /**
  *  Produce a handler for the child worker
  */
-export function buildStandardTestManager(consumer: TestConsumer) {
+export function buildStandardTestManager(consumer: TestConsumer): () => Worker<string> {
   /**
    * Spawn a child
    */
@@ -21,7 +20,7 @@ export function buildStandardTestManager(consumer: TestConsumer) {
     /**
      * Child initialization
      */
-    async (channel: ParentCommChannel<TestEvent>) => {
+    async (channel: ParentCommChannel<TestEvent>): Promise<void> => {
       await channel.once(Events.READY); // Wait for the child to be ready
       await channel.send(Events.INIT); // Initialize
       await channel.once(Events.INIT_COMPLETE); // Wait for complete
@@ -36,7 +35,7 @@ export function buildStandardTestManager(consumer: TestConsumer) {
     /**
      * Send child command to run tests
      */
-    async (channel: ParentCommChannel<TestEvent>, event: string | RunEvent) => {
+    async (channel: ParentCommChannel<TestEvent & { error?: Error }>, event: string | RunEvent): Promise<void> => {
       // Listen for child to complete
       const complete = channel.once(Events.RUN_COMPLETE);
       // Start test
@@ -44,7 +43,7 @@ export function buildStandardTestManager(consumer: TestConsumer) {
       channel.send(Events.RUN, event);
 
       // Wait for complete
-      const { error } = await (complete as unknown as TestResult);
+      const { error } = await complete;
 
       // If we received an error, throw it
       if (error) {

package/support/phase.reset.ts

@@ -4,7 +4,7 @@
 export const init = {
   key: '@trv:test/rest',
   before: ['@trv:registry/reset'],
-  action: async () => {
+  action: async (): Promise<void> => {
     const { SuiteRegistry } = await import('../src/registry/suite');
     // Clear the registry
     await SuiteRegistry.reset();

package/support/transformer.annotate.ts

@@ -17,16 +17,17 @@ export class AnnotationTransformer {
    * @param node
    * @param dec
   */
-  static buildAnnotation(state: TransformerState, node: ts.Node, dec: ts.Decorator & { expression: ts.CallExpression }) {
-    const n = (CoreUtil.hasOriginal(node) ? node.original : node) as ts.MethodDeclaration;
+  static buildAnnotation(state: TransformerState, node: ts.Node, dec: ts.Decorator, expression: ts.CallExpression): ts.Decorator {
+    const ogN = (CoreUtil.hasOriginal(node) ? node.original : node);
+    const n = ts.isMethodDeclaration(ogN) ? ogN : undefined;
 
     const newDec = state.factory.updateDecorator(
       dec,
       state.factory.createCallExpression(
-        dec.expression.expression,
-        dec.expression.typeArguments,
+        expression.expression,
+        expression.typeArguments,
         [
-          ...(dec.expression.arguments ?? []),
+          ...(expression.arguments ?? []),
           state.fromLiteral({
             lines: {
               ...CoreUtil.getRangeOf(state.source, n),
@@ -40,11 +41,11 @@ export class AnnotationTransformer {
   }
 
   @OnClass('Suite')
-  static annotateSuiteDetails(state: TransformerState, node: ts.ClassDeclaration, dm?: DecoratorMeta) {
+  static annotateSuiteDetails(state: TransformerState, node: ts.ClassDeclaration, dm?: DecoratorMeta): ts.ClassDeclaration {
     const dec = dm?.dec;
 
     if (dec && ts.isCallExpression(dec.expression)) {
-      const newDec = this.buildAnnotation(state, node, dec as ts.Decorator & { expression: ts.CallExpression });
+      const newDec = this.buildAnnotation(state, node, dec, dec.expression);
       return state.factory.updateClassDeclaration(node,
         DecoratorUtil.spliceDecorators(node, dec, [newDec]),
         node.modifiers,
@@ -58,11 +59,11 @@ export class AnnotationTransformer {
   }
 
   @OnMethod('Test')
-  static annotateTestDetails(state: TransformerState, node: ts.MethodDeclaration, dm?: DecoratorMeta) {
+  static annotateTestDetails(state: TransformerState, node: ts.MethodDeclaration, dm?: DecoratorMeta): ts.MethodDeclaration {
     const dec = dm?.dec;
 
     if (dec && ts.isCallExpression(dec.expression)) {
-      const newDec = this.buildAnnotation(state, node, dec as ts.Decorator & { expression: ts.CallExpression });
+      const newDec = this.buildAnnotation(state, node, dec, dec.expression);
       return state.factory.updateMethodDeclaration(node,
         DecoratorUtil.spliceDecorators(node, dec, [newDec]),
         node.modifiers,

package/support/transformer.assert.ts

@@ -47,7 +47,7 @@ const METHODS: Record<string, Function[]> = {
   test: [RegExp]
 };
 
-const OP_TOKEN_TO_NAME = new Map<number, string>();
+const OP_TOKEN_TO_NAME = new Map<number, keyof typeof OPTOKEN_ASSERT>();
 
 const AssertⲐ = Symbol.for('@trv:test/assert');
 const IsTestⲐ = Symbol.for('@trv:test/valid');
@@ -96,19 +96,18 @@ export class AssertTransformer {
   /**
    * Resolves optoken to syntax kind.  Relies on `ts`
    */
-  static lookupOpToken(key: number) {
+  static lookupOpToken(key: number): string {
     if (OP_TOKEN_TO_NAME.size === 0) {
       Object.keys(ts.SyntaxKind)
         .filter(x => !/^\d+$/.test(x))
-        .filter(x => !/^(Last|First)/.test(x))
+        .filter((x): x is keyof typeof OPTOKEN_ASSERT => !/^(Last|First)/.test(x))
         .forEach(x =>
-          OP_TOKEN_TO_NAME.set(
-            ts.SyntaxKind[x as 'Unknown'], x));
+          OP_TOKEN_TO_NAME.set(ts.SyntaxKind[x], x));
     }
 
     const name = OP_TOKEN_TO_NAME.get(key)!;
     if (name in OPTOKEN_ASSERT) {
-      return OPTOKEN_ASSERT[name as keyof typeof OPTOKEN_ASSERT];
+      return OPTOKEN_ASSERT[name];
     } else {
       throw new Error(`Unknown optoken: ${name}:${key}`);
     }
@@ -117,7 +116,7 @@ export class AssertTransformer {
   /**
    * Determine if element is a deep literal (should use deep comparison)
    */
-  static isDeepLiteral(state: TransformerState, node: ts.Expression) {
+  static isDeepLiteral(state: TransformerState, node: ts.Expression): boolean {
     let found = ts.isArrayLiteralExpression(node) ||
       ts.isObjectLiteralExpression(node) ||
       (
@@ -139,7 +138,7 @@ export class AssertTransformer {
   /**
    * Initialize transformer state
    */
-  static initState(state: TransformerState & AssertState) {
+  static initState(state: TransformerState & AssertState): void {
     if (!state[AssertⲐ]) {
       const assrt = state.importFile('@travetto/test/src/assert/check').ident;
       state[AssertⲐ] = {
@@ -154,7 +153,7 @@ export class AssertTransformer {
   /**
    * Convert the assert to call the framework `AssertUtil.check` call
    */
-  static doAssert<T extends ts.CallExpression>(state: TransformerState & AssertState, node: T, cmd: Command): T {
+  static doAssert(state: TransformerState & AssertState, node: ts.CallExpression, cmd: Command): ts.CallExpression {
     this.initState(state);
 
     const first = CoreUtil.getArgument<ts.CallExpression>(node);
@@ -172,13 +171,13 @@ export class AssertTransformer {
       ...cmd.args
     ]));
 
-    return check as T;
+    return check;
   }
 
   /**
    * Convert `assert.(throws|rejects|doesNotThrow|doesNotReject)` to the appropriate structure
    */
-  static doThrows(state: TransformerState & AssertState, node: ts.CallExpression, key: string, args: ts.Expression[]): ts.Node {
+  static doThrows(state: TransformerState & AssertState, node: ts.CallExpression, key: string, args: ts.Expression[]): ts.CallExpression {
     const first = CoreUtil.getArgument<ts.CallExpression>(node);
     const firstText = first!.getText();
 
@@ -201,7 +200,7 @@ export class AssertTransformer {
   /**
    * Check a binary expression (left and right) to see how we should communicate the assert
    */
-  static doBinaryCheck(state: TransformerState, comp: ts.BinaryExpression, message: Message, args: Args) {
+  static doBinaryCheck(state: TransformerState, comp: ts.BinaryExpression, message: Message, args: Args): Command {
     let opFn = this.lookupOpToken(comp.operatorToken.kind);
 
     if (opFn) {
@@ -218,7 +217,7 @@ export class AssertTransformer {
   /**
    * Check unary operator
    */
-  static doUnaryCheck(state: TransformerState, comp: ts.PrefixUnaryExpression, message: Message, args: Args) {
+  static doUnaryCheck(state: TransformerState, comp: ts.PrefixUnaryExpression, message: Message, args: Args): Command {
     if (ts.isPrefixUnaryExpression(comp.operand)) {
       const inner = comp.operand.operand;
       return { fn: 'ok', args: [inner, message!] };
@@ -231,7 +230,7 @@ export class AssertTransformer {
   /**
    * Check various `assert.*` method calls
    */
-  static doMethodCall(state: TransformerState, comp: ts.Expression, args: Args) {
+  static doMethodCall(state: TransformerState, comp: ts.Expression, args: Args): Command {
 
     if (ts.isCallExpression(comp) && ts.isPropertyAccessExpression(comp.expression)) {
       const root = comp.expression.expression;
@@ -275,7 +274,7 @@ export class AssertTransformer {
    * Listen for all call expression
    */
   @OnCall()
-  static onAssertCall(state: TransformerState & AssertState, node: ts.CallExpression) {
+  static onAssertCall(state: TransformerState & AssertState, node: ts.CallExpression): ts.CallExpression {
     // If not in test mode, see if file is valid
     if (state[IsTestⲐ] === undefined) {
       const name = PathUtil.toUnix(state.source.fileName);
@@ -303,7 +302,7 @@ export class AssertTransformer {
       if (ident.escapedText === ASSERT_CMD) {
         // Look for reject/throw
         if (/^(doesNot)?(Throw|Reject)s?$/i.test(fn)) {
-          node = this.doThrows(state, node, fn, [...node.arguments]) as ts.CallExpression;
+          node = this.doThrows(state, node, fn, [...node.arguments]);
         } else {
           const sub = { ...this.getCommand(state, node.arguments)!, fn };
           node = this.doAssert(state, node, sub);