@travetto/test 8.0.0-alpha.20 → 8.0.0-alpha.21

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,9 +1,9 @@
 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';
 
@@ -15,12 +15,12 @@ import type { TestConsumerType } from './bin/run.ts';
  */
 @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;
 
   /**
@@ -52,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,7 +1,7 @@
 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';
 
 /**
@@ -27,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,11 +1,11 @@
 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';
 
 /**
  * Run tests scoped by a precomputed diff source file.
@@ -16,7 +16,6 @@ import type { TestDiffSource } from '../src/model/test.ts';
 @CliCommand()
 @IsPrivate()
 export class TestDiffCommand {
-
   /** Output format for test results */
   format: TestConsumerType = 'tap';
 
@@ -34,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,
@@ -47,4 +46,4 @@ export class TestDiffCommand {
       }
     );
   }
-}
+}

package/support/cli.test_digest.ts

@@ -1,10 +1,10 @@
 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()
@@ -15,7 +15,6 @@ import { RunUtil } from '../src/execute/run.ts';
  * order for planning, sharding, or change detection workflows.
  */
 export class TestDigestCommand {
-
   /** Output mode for digest emission. */
   output: 'json' | 'text' = 'text';
 
@@ -54,4 +53,4 @@ export class TestDigestCommand {
       }
     }
   }
-}
+}

package/support/cli.test_direct.ts

@@ -1,5 +1,5 @@
-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';
@@ -13,7 +13,6 @@ import { runTests, type TestConsumerType } from './bin/run.ts';
 @CliCommand()
 @IsPrivate()
 export class TestDirectCommand {
-
   /** Output format for test results */
   format: TestConsumerType = 'tap';
 
@@ -31,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,5 +1,5 @@
-import { Env } from '@travetto/runtime';
 import { CliCommand } from '@travetto/cli';
+import { Env } from '@travetto/runtime';
 
 import type { TestConsumerType } from './bin/run.ts';
 
@@ -11,7 +11,6 @@ import type { TestConsumerType } from './bin/run.ts';
  */
 @CliCommand()
 export class TestWatcherCommand {
-
   /** Output format for test results */
   format: TestConsumerType = 'tap';
 
@@ -29,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
@@ -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']);
@@ -104,8 +103,9 @@ export class AssertTransformer {
       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));
+        .forEach(kind => {
+          OP_TOKEN_TO_NAME.set(ts.SyntaxKind[kind], kind);
+        });
     }
 
     const name = OP_TOKEN_TO_NAME.get(key)!;
@@ -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;
@@ -148,7 +147,7 @@ export class AssertTransformer {
         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'),
+        checkThrowAsync: CoreUtil.createAccess(state.factory, asrt, 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;
   }
-}
+}