@travetto/test 3.0.3 → 3.1.0-rc.1

package/README.md

@@ -220,13 +220,13 @@ To run the tests you can either call the [Command Line Interface](https://github
 ```bash
 $ trv test --help
 
-Usage:  test [options] [regexes...]
+Usage: test [options] [first:string] [regexes...:string]
 
 Options:
-  -f, --format <format>            Output format for test results (default: "tap")
-  -c, --concurrency <concurrency>  Number of tests to run concurrently (default: 4)
-  -m, --mode <mode>                Test run mode (default: "standard")
-  -h, --help                       display help for command
+  -f, --format <string>         Output format for test results (default: "tap")
+  -c, --concurrency <number>    Number of tests to run concurrently (default: 7)
+  -m, --mode <single|standard>  Test run mode (default: "standard")
+  -h, --help                    display help for command
 ```
 
 The regexes are the patterns of tests you want to run, and all tests must be found under the `test/` folder.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/test",
-  "version": "3.0.3",
+  "version": "3.1.0-rc.1",
   "description": "Declarative test framework",
   "keywords": [
     "unit-testing",
@@ -27,15 +27,15 @@
     "directory": "module/test"
   },
   "dependencies": {
-    "@travetto/base": "^3.0.3",
-    "@travetto/registry": "^3.0.3",
-    "@travetto/terminal": "^3.0.3",
-    "@travetto/worker": "^3.0.3",
-    "@travetto/yaml": "^3.0.3"
+    "@travetto/base": "^3.1.0-rc.0",
+    "@travetto/registry": "^3.1.0-rc.0",
+    "@travetto/terminal": "^3.1.0-rc.0",
+    "@travetto/worker": "^3.1.0-rc.0",
+    "@travetto/yaml": "^3.1.0-rc.0"
   },
   "peerDependencies": {
-    "@travetto/cli": "^3.0.3",
-    "@travetto/transformer": "^3.0.3"
+    "@travetto/cli": "^3.1.0-rc.1",
+    "@travetto/transformer": "^3.1.0-rc.0"
   },
   "peerDependenciesMeta": {
     "@travetto/transformer": {

package/src/assert/check.ts

@@ -70,7 +70,7 @@ export class AssertCheck {
     } else if (fn === 'includes') {
       assertion.operator = fn;
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      [assertion.expected, assertion.actual, assertion.message] = args as [unknown, unknown, string];
+      [assertion.actual, assertion.expected, assertion.message] = args as [unknown, unknown, string];
     } else if (fn === 'instanceof') {
       assertion.operator = fn;
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
@@ -98,6 +98,10 @@ export class AssertCheck {
 
       // Actually run the assertion
       switch (fn) {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        case 'includes': assertFn((actual as unknown[]).includes(expected), message); break;
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        case 'test': assertFn((expected as RegExp).test(actual as string), message); break;
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         case 'instanceof': assertFn(actual instanceof (expected as Class), message); break;
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
@@ -120,10 +124,6 @@ export class AssertCheck {
             }
             // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
             assert[fn as 'ok'].apply(null, args as [boolean, string | undefined]);
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          } else if (expected && !!(expected as Record<string, Function>)[fn]) { // Dotted Method call (e.g. assert.rejects)
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            assertFn((expected as typeof assert)[fn as 'ok'](actual));
           }
       }
 

package/src/assert/util.ts

@@ -41,7 +41,7 @@ export class AssertUtil {
    * Determine file location for a given error and the stack trace
    */
   static getPositionOfError(err: Error, filename: string): { file: string, line: number } {
-    const cwd = path.cwd();
+    const cwd = RootIndex.mainModule.sourcePath;
     const lines = path.toPosix(err.stack ?? new Error().stack!)
       .split('\n')
       // Exclude node_modules, target self

package/src/consumer/registry.ts

@@ -58,9 +58,8 @@ export const TestConsumerRegistry = new $TestConsumerRegistry();
  * @param type The unique identifier for the consumer
  * @param isDefault Is this the default consumer.  Last one wins
  */
-export function Consumable(type: string, isDefault = false): ClassDecorator {
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  return function (cls: Class<TestConsumer>) {
+export function Consumable(type: string, isDefault = false): (cls: Class<TestConsumer>) => void {
+  return function (cls: Class<TestConsumer>): void {
     TestConsumerRegistry.add(type, cls, isDefault);
-  } as ClassDecorator;
+  };
 }

package/src/consumer/types/runnable.ts

@@ -1,4 +1,4 @@
-import { TestConsumer } from '../types';
+import { TestConsumer, TestRunState } from '../types';
 import { TestResultsSummarizer } from './summarizer';
 import { TestConsumerRegistry } from '../registry';
 import { TestEvent } from '../../model/event';
@@ -27,9 +27,9 @@ export class RunnableTestConsumer implements TestConsumer {
     }
   }
 
-  async onStart(files: string[]): Promise<void> {
+  async onStart(state: TestRunState): Promise<void> {
     for (const c of this.#consumers) {
-      await c.onStart?.(files);
+      await c.onStart?.(state);
     }
   }
 

package/src/consumer/types/tap-streamed.ts

@@ -1,13 +1,12 @@
 import { GlobalTerminal, TermStyleInput, Terminal } from '@travetto/terminal';
 import { ManualAsyncIterator } from '@travetto/worker';
-import { RootIndex } from '@travetto/manifest';
-
-import { SuitesSummary, TestConsumer } from '../types';
-import { Consumable } from '../registry';
 
 import { TestEvent } from '../../model/event';
 import { TestResult } from '../../model/test';
-import { SuiteRegistry } from '../../registry/suite';
+
+import { SuitesSummary, TestConsumer, TestRunState } from '../types';
+import { Consumable } from '../registry';
+
 import { TapEmitter } from './tap';
 
 /**
@@ -49,25 +48,12 @@ export class TapStreamedEmitter implements TestConsumer {
     this.#consumer = new TapEmitter(this.#terminal);
   }
 
-  async onStart(files: string[]): Promise<void> {
+  async onStart(state: TestRunState): Promise<void> {
     this.#consumer.onStart();
 
-    // Load all tests
-    for (const file of files) {
-      await import(RootIndex.getFromSource(file)!.import);
-    }
-
-    await SuiteRegistry.init();
-
-    const suites = SuiteRegistry.getClasses();
-    const total = suites
-      .map(c => SuiteRegistry.get(c))
-      .filter(c => !RootIndex.getFunctionMetadata(c.class)?.abstract)
-      .reduce((acc, c) => acc + (c.tests?.length ?? 0), 0);
-
     this.#progress = this.#terminal.streamToPosition(this.#results,
-      TapStreamedEmitter.makeProgressBar(this.#terminal, total),
-      { position: 'bottom' }
+      TapStreamedEmitter.makeProgressBar(this.#terminal, state.testCount ?? 0),
+      { position: 'bottom', minDelay: 100 }
     );
   }
 

package/src/consumer/types/tap.ts

@@ -1,4 +1,4 @@
-import { path } from '@travetto/manifest';
+import { RootIndex } from '@travetto/manifest';
 import { GlobalTerminal, Terminal } from '@travetto/terminal';
 import { ErrorUtil, ObjectUtil, TimeUtil } from '@travetto/base';
 import { YamlUtil } from '@travetto/yaml';
@@ -61,8 +61,6 @@ export class TapEmitter implements TestConsumer {
       }
       this.log(`# ${header}`);
 
-      const cwd = path.cwd();
-
       // Handle each assertion
       if (test.assertions.length) {
         let subCount = 0;
@@ -72,7 +70,7 @@ export class TapEmitter implements TestConsumer {
             this.#enhancer.assertNumber(++subCount),
             '-',
             this.#enhancer.assertDescription(text),
-            `${this.#enhancer.assertFile(asrt.file.replace(cwd, '.'))}:${this.#enhancer.assertLine(asrt.line)}`
+            `${this.#enhancer.assertFile(asrt.file.replace(RootIndex.mainModule.sourcePath, '.'))}:${this.#enhancer.assertLine(asrt.line)}`
           ].join(' ');
 
           if (asrt.error) {

package/src/consumer/types.ts

@@ -19,6 +19,10 @@ export interface SuitesSummary extends Counts {
   duration: number;
 }
 
+export type TestRunState = {
+  testCount?: number;
+};
+
 /**
  * A test result handler
  */
@@ -26,7 +30,7 @@ export interface TestConsumer {
   /**
    * Listen for start of the test run
    */
-  onStart?(files: string[]): Promise<void> | void;
+  onStart?(testState: TestRunState): Promise<void> | void;
   /**
    * Handle individual tests events
    */

package/src/execute/executor.ts

@@ -71,7 +71,7 @@ export class TestExecutor {
     const classId = RootIndex.getId(file, name);
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     const suite = { class: { name }, classId, duration: 0, lines: { start: 1, end: 1 }, file, } as SuiteConfig & SuiteResult;
-    err.message = err.message.replace(path.cwd(), '.');
+    err.message = err.message.replaceAll(RootIndex.mainModule.sourcePath, '.');
     const res = AssertUtil.generateSuiteError(suite, 'require', err);
     consumer.onEvent({ type: 'suite', phase: 'before', suite });
     consumer.onEvent({ type: 'test', phase: 'before', test: res.testConfig });

package/src/execute/runner.ts

@@ -42,7 +42,8 @@ export class Runner {
       max: this.#state.concurrency
     });
 
-    await consumer.onStart(files);
+    const testCount = await RunnerUtil.getTestCount(this.#state.args);
+    await consumer.onStart({ testCount });
     await pool.process(new IterableWorkSet(files));
     return consumer.summarizeAsBoolean();
   }
@@ -55,7 +56,7 @@ export class Runner {
 
     const [file, ...args] = this.#state.args;
 
-    await consumer.onStart([path.resolve(file)]);
+    await consumer.onStart({});
     await TestExecutor.execute(consumer, file, ...args);
     return consumer.summarizeAsBoolean();
   }

package/src/execute/util.ts

@@ -1,7 +1,7 @@
 import { createReadStream } from 'fs';
 import readline from 'readline';
 
-import { ShutdownManager, TimeUtil } from '@travetto/base';
+import { ExecUtil, ShutdownManager, TimeUtil } from '@travetto/base';
 import { RootIndex } from '@travetto/manifest';
 
 /**
@@ -47,4 +47,18 @@ export class RunnerUtil {
       .filter(x => x.valid)
       .map(x => x.file);
   }
+
+  /**
+   * Get count of tests for a given set of patterns
+   * @param patterns
+   * @returns
+   */
+  static async getTestCount(patterns: string[]): Promise<number> {
+    const proc = ExecUtil.spawn('npx', ['trv', 'test:count', ...patterns], { stdio: 'pipe', catchAsResult: true });
+    const countRes = await proc.result;
+    if (!countRes.valid) {
+      throw new Error(countRes.stderr);
+    }
+    return countRes.valid ? +countRes.stdout : 0;
+  }
 }

package/src/execute/watcher.ts

@@ -1,7 +1,7 @@
 import { RootRegistry, MethodSource } from '@travetto/registry';
 import { WorkPool, IterableWorkSet, ManualAsyncIterator } from '@travetto/worker';
 import { RootIndex } from '@travetto/manifest';
-import { ConsoleManager, defineGlobalEnv, ObjectUtil } from '@travetto/base';
+import { ObjectUtil } from '@travetto/base';
 
 import { SuiteRegistry } from '../registry/suite';
 import { buildStandardTestManager } from '../worker/standard';
@@ -86,20 +86,4 @@ export class TestWatcher {
 
     await pool.process(src);
   }
-}
-
-export async function main(format: string = 'tap', runAllOnStart: string = 'true'): Promise<void> {
-  defineGlobalEnv({ test: true, dynamic: true });
-  console.log('Starting');
-  ConsoleManager.setDebugFromEnv();
-  // Quit on parent disconnect
-  if (process.send) {
-    process.on('disconnect', () => process.exit(0));
-  }
-  try {
-    await TestWatcher.watch(format, runAllOnStart !== 'false');
-    console.log('Done');
-  } catch (err) {
-    console.error(err);
-  }
 }

package/src/worker/child.ts

@@ -1,7 +1,7 @@
 import fs from 'fs/promises';
 
 import { path } from '@travetto/manifest';
-import { ConsoleManager, defineGlobalEnv, ErrorUtil, TimeUtil } from '@travetto/base';
+import { ConsoleManager, ErrorUtil, TimeUtil } from '@travetto/base';
 import { ChildCommChannel } from '@travetto/worker';
 
 import { RunnerUtil } from '../execute/util';
@@ -88,10 +88,4 @@ export class TestChildWorker extends ChildCommChannel<RunEvent> {
       concurrency: 1
     }).run();
   }
-}
-
-export async function main(): Promise<void> {
-  defineGlobalEnv({ test: true, set: { FORCE_COLOR: 0 } });
-  ConsoleManager.setDebugFromEnv();
-  await new TestChildWorker().activate();
 }

package/src/worker/standard.ts

@@ -37,11 +37,11 @@ export function buildStandardTestManager(consumer: TestConsumer): () => Worker<s
       const channel = new ParentCommChannel<TestEvent & { error?: Error }>(
         ExecUtil.fork(
           RootIndex.resolveFileImport('@travetto/cli/support/entry.cli'),
-          ['main', '@travetto/test/src/worker/child.ts'],
+          ['test:child'],
           {
             cwd,
-            env: { TRV_MANIFEST: RootIndex.getModule(module)!.outputPath },
-            stdio: [0, 'ignore', 2, 'ipc']
+            env: { TRV_MANIFEST: RootIndex.getModule(module)!.outputPath, TRV_QUIET: '1' },
+            stdio: ['ignore', 'ignore', 2, 'ipc']
           }
         )
       );

package/support/bin/run.ts

@@ -1,8 +1,5 @@
 import { ShutdownManager, TimeUtil } from '@travetto/base';
 
-import { RunnerUtil } from '../../src/execute/util';
-import { Runner } from '../../src/execute/runner';
-
 import type { RunState } from '../../src/execute/types';
 
 declare global {
@@ -19,6 +16,9 @@ declare global {
  * @param opts
  */
 export async function runTests(opts: RunState): Promise<void> {
+  const { RunnerUtil } = await import('../../src/execute/util.js');
+  const { Runner } = await import('../../src/execute/runner.js');
+
   RunnerUtil.registerCleanup('runner');
 
   if (process.env.TRV_TEST_DELAY) {

package/support/bin/types.ts

@@ -0,0 +1,2 @@
+export type TestFormat = 'tap' | 'tap-streamed' | 'xunit' | 'event' | 'exec';
+export type TestMode = 'single' | 'standard';

package/support/cli.test.ts

@@ -1,76 +1,57 @@
-import { readFileSync } from 'fs';
 import fs from 'fs/promises';
 
-import { path, RootIndex } from '@travetto/manifest';
+import { path } from '@travetto/manifest';
 import { GlobalEnvConfig } from '@travetto/base';
-import { CliCommand, OptionConfig } from '@travetto/cli';
+import { CliCommandShape, CliCommand, CliValidationError } from '@travetto/cli';
 import { WorkPool } from '@travetto/worker';
+import { Max, Min } from '@travetto/schema';
 
-import type { RunState } from '../src/execute/types';
-
-const modes = ['single', 'standard'] as const;
-
-type Options = {
-  format: OptionConfig<string>;
-  concurrency: OptionConfig<number>;
-  mode: OptionConfig<(typeof modes)[number]>;
-};
+import { TestFormat, TestMode } from './bin/types';
 
 /**
  * Launch test framework and execute tests
  */
-export class TestCommand extends CliCommand<Options> {
-  name = 'test';
-  _types: string[];
-
-  getTypes(): string[] {
-    if (!this._types) {
-      this._types = RootIndex
-        .findSrc({ filter: /consumer\/types\/.*/, profiles: ['test'] })
-        .map(x => readFileSync(`${x.outputFile}`, 'utf8').match(/Consumable.?[(]'([^']+)/)?.[1])
-        .filter((x?: string): x is string => !!x);
-    }
-    return this._types;
-  }
-
-  getOptions(): Options {
-    return {
-      format: this.choiceOption({ desc: 'Output format for test results', def: 'tap', choices: this.getTypes() }),
-      concurrency: this.intOption({ desc: 'Number of tests to run concurrently', lower: 1, upper: 32, def: WorkPool.DEFAULT_SIZE }),
-      mode: this.choiceOption({ desc: 'Test run mode', def: 'standard', choices: [...modes] })
-    };
-  }
+@CliCommand()
+export class TestCommand implements CliCommandShape {
+  /** Output format for test results */
+  format: TestFormat = 'tap';
+  /** Number of tests to run concurrently */
+  @Min(1) @Max(WorkPool.MAX_SIZE)
+  concurrency: number = WorkPool.MAX_SIZE;
+  /** Test run mode */
+  mode: TestMode = 'standard';
 
   envInit(): GlobalEnvConfig {
     return { test: true };
   }
 
-  getArgs(): string {
-    return '[regexes...]';
+  isFirstFile(first: string): Promise<boolean> {
+    return fs.stat(path.resolve(first ?? '')).then(x => x.isFile(), () => false);
   }
 
-  async action(regexes: string[]): Promise<void> {
-    const { runTests } = await import('./bin/run.js');
-
-    const [first] = regexes;
+  async resolvedMode(first: string, rest: string[]): Promise<TestMode> {
+    return (await this.isFirstFile(first)) && rest.length === 0 ? 'single' : this.mode;
+  }
 
-    const isFile = await fs.stat(path.resolve(first ?? '')).then(x => x.isFile(), () => false);
+  async validate(first: string = 'test/.*', rest: string[]): Promise<CliValidationError | undefined> {
 
-    const state: RunState = {
-      args: !first ? ['test/.*'] : regexes,
-      mode: isFile && regexes.length === 1 ? 'single' : this.cmd.mode,
-      concurrency: this.cmd.concurrency,
-      format: this.cmd.format
-    };
+    const mode = await this.resolvedMode(first, rest);
 
-    if (state.mode === 'single') {
-      if (!isFile) {
-        return this.showHelp('You must specify a proper test file to run in single mode');
-      } else if (!/test\//.test(first)) {
-        return this.showHelp('Only files in the test/ folder are permitted to be run');
-      }
+    if (mode === 'single' && !await this.isFirstFile(first)) {
+      return { message: 'You must specify a proper test file to run in single mode', source: 'arg' };
+    } else if (!/test\//.test(first)) {
+      return { message: 'Only files in the test/ folder are permitted to be run', source: 'arg' };
     }
+  }
+
+  async main(first: string = 'test/.*', regexes: string[] = []): Promise<void> {
+    const { runTests } = await import('./bin/run.js');
 
-    await runTests(state);
+    return runTests({
+      args: [first, ...regexes],
+      mode: await this.resolvedMode(first, regexes),
+      concurrency: this.concurrency,
+      format: this.format
+    });
   }
 }

package/support/cli.test_child.ts

@@ -0,0 +1,19 @@
+import { GlobalEnvConfig, ShutdownManager } from '@travetto/base';
+import { CliCommand } from '@travetto/cli';
+
+/** Test child worker target */
+@CliCommand({ hidden: true })
+export class TestChildWorkerCommand {
+  envInit(): GlobalEnvConfig {
+    return { test: true, set: { FORCE_COLOR: 0 } };
+  }
+
+  async main(): Promise<void> {
+    if (process.send) {
+      // Shutdown when ipc bridge is closed
+      process.on('disconnect', () => ShutdownManager.execute());
+    }
+    const { TestChildWorker } = await import('../src/worker/child.js');
+    return new TestChildWorker().activate();
+  }
+}

package/support/cli.test_count.ts

@@ -0,0 +1,34 @@
+import { CliCommand } from '@travetto/cli';
+import { RootIndex } from '@travetto/manifest';
+
+import { SuiteRegistry } from '../src/registry/suite';
+import { RunnerUtil } from '../src/execute/util';
+import { GlobalEnvConfig } from '@travetto/base';
+
+@CliCommand({ hidden: true })
+export class TestCountCommand {
+
+  envInit(): GlobalEnvConfig {
+    return { debug: false, test: true };
+  }
+
+  async main(patterns: string[]) {
+    const regexes = patterns.map(x => new RegExp(x));
+    const files = await RunnerUtil.getTestFiles(regexes);
+
+    // Load all tests
+    for (const file of files) {
+      await import(RootIndex.getFromSource(file)!.import);
+    }
+
+    await SuiteRegistry.init();
+
+    const suites = SuiteRegistry.getClasses();
+    const total = suites
+      .map(c => SuiteRegistry.get(c))
+      .filter(c => !RootIndex.getFunctionMetadata(c.class)?.abstract)
+      .reduce((acc, c) => acc + (c.tests?.length ?? 0), 0);
+
+    console.log(total);
+  }
+}

package/support/cli.test_direct.ts

@@ -0,0 +1,20 @@
+import { GlobalEnvConfig } from '@travetto/base';
+import { CliCommand } from '@travetto/cli';
+
+import { runTests } from './bin/run';
+import { TestFormat } from './bin/types';
+
+/**  Direct test invocation */
+@CliCommand({ hidden: true })
+export class TestDirectCommand {
+
+  format: TestFormat = 'tap';
+
+  envInit(): GlobalEnvConfig {
+    return { test: true };
+  }
+
+  main(file: string, args: string[]): Promise<void> {
+    return runTests({ args: [file, ...args], format: this.format, mode: 'single', concurrency: 1 });
+  }
+}

package/support/cli.test_watch.ts

@@ -0,0 +1,34 @@
+import { GlobalEnvConfig } from '@travetto/base';
+import { CliCommand } from '@travetto/cli';
+
+import { TestFormat } from './bin/types';
+
+/**
+ * Invoke the test watcher
+ */
+@CliCommand()
+export class TestWatcherCommand {
+
+  format: TestFormat = 'tap';
+  mode: 'all' | 'change' = 'all';
+
+  envInit(): GlobalEnvConfig {
+    return { test: true, dynamic: true };
+  }
+
+  async main(): Promise<void> {
+    // Quit on parent disconnect
+    if (process.send) {
+      process.on('disconnect', () => process.exit(0));
+    }
+
+    try {
+      const { TestWatcher } = await import('../src/execute/watcher.js');
+      console.log('Starting');
+      await TestWatcher.watch(this.format, this.mode === 'all');
+      console.log('Done');
+    } catch (err) {
+      console.error(err);
+    }
+  }
+}

package/support/transformer.assert.ts

@@ -237,10 +237,10 @@ export class AssertTransformer {
       if (matched) {
         const resolved = state.resolveType(root);
         if (resolved.key === 'literal' && matched.find(x => resolved.ctor === x)) { // Ensure method is against real type
-          return {
-            fn: key.text,
-            args: [comp.arguments[0], comp.expression.expression, ...args.slice(1)]
-          };
+          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)] };
+          }
         }
       }
     }

package/support/bin/direct.ts

@@ -1,15 +0,0 @@
-import { ConsoleManager, defineGlobalEnv } from '@travetto/base';
-import { runTests } from './run';
-
-// Direct entry point
-export function main(...args: string[]): Promise<void> {
-  defineGlobalEnv({ test: true });
-  ConsoleManager.setDebugFromEnv();
-
-  return runTests({
-    args,
-    format: process.env.TRV_TEST_FORMAT ?? 'tap',
-    mode: 'single',
-    concurrency: 1
-  });
-}