@travetto/test 7.0.0-rc.1 → 7.0.0-rc.3

package/README.md

@@ -21,7 +21,7 @@ This module provides unit testing functionality that integrates with the framewo
 **Note**: All tests should be under the `**/*` folders.  The pattern for tests is defined as as a standard glob using [Node](https://nodejs.org)'s built in globbing support.
 
 ## Definition
-A test suite is a collection of individual tests.  All test suites are classes with the [@Suite](https://github.com/travetto/travetto/tree/main/module/test/src/decorator/suite.ts#L14) decorator. Tests are defined as methods on the suite class, using the [@Test](https://github.com/travetto/travetto/tree/main/module/test/src/decorator/test.ts#L23) decorator.  All tests intrinsically support `async`/`await`. 
+A test suite is a collection of individual tests.  All test suites are classes with the [@Suite](https://github.com/travetto/travetto/tree/main/module/test/src/decorator/suite.ts#L14) decorator. Tests are defined as methods on the suite class, using the [@Test](https://github.com/travetto/travetto/tree/main/module/test/src/decorator/test.ts#L25) decorator.  All tests intrinsically support `async`/`await`. 
 
 A simple example would be:
 
@@ -35,14 +35,14 @@ import { Suite, Test } from '@travetto/test';
 class SimpleTest {
 
   #complexService: {
-    doLongOp(): Promise<number>;
+    doLongOperation(): Promise<number>;
     getText(): string;
   };
 
   @Test()
   async test1() {
-    const val = await this.#complexService.doLongOp();
-    assert(val === 5);
+    const value = await this.#complexService.doLongOperation();
+    assert(value === 5);
   }
 
   @Test()
@@ -212,8 +212,8 @@ class SimpleTest {
 
     await assert.rejects(() => {
       throw new Error('Big Error');
-    }, (err: Error) =>
-      err.message.startsWith('Big') && err.message.length > 4
+    }, (error: Error) =>
+      error.message.startsWith('Big') && error.message.length > 4
     );
   }
 }
@@ -231,8 +231,7 @@ Usage: test [options] [first:string] [globs...:string]
 Options:
   -f, --format <string>          Output format for test results (default: "tap")
   -c, --concurrency <number>     Number of tests to run concurrently (default: 9)
-  -m, --mode <single|standard>   Test run mode (default: "standard")
-  -t, --tags <string>            Tags to target or exclude
+  -t, --tags <string>            Tags to target or exclude when using globs
   -o, --format-options <string>  Format options
   -h, --help                     display help for command
 ```

package/__index__.ts

@@ -4,6 +4,7 @@ export * from './src/decorator/test.ts';
 export * from './src/model/suite.ts';
 export * from './src/model/test.ts';
 export * from './src/model/event.ts';
+export * from './src/model/util.ts';
 export * from './src/registry/registry-index.ts';
 export * from './src/registry/registry-adapter.ts';
 export * from './src/fixture.ts';

package/package.json

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

package/src/assert/check.ts

@@ -13,7 +13,7 @@ type StringFields<T> = {
   (T[K] extends string ? K : never)
 }[Extract<keyof T, string>];
 
-const isClass = (e: unknown): e is Class => e === Error || e === AppError || Object.getPrototypeOf(e) !== Object.getPrototypeOf(Function);
+const isClass = (input: unknown): input is Class => input === Error || input === AppError || Object.getPrototypeOf(input) !== Object.getPrototypeOf(Function);
 
 /**
  * Check assertion
@@ -35,7 +35,7 @@ export class AssertCheck {
     };
 
     // Invert check for negative
-    const assertFn = positive ? assert : (x: unknown, msg?: string): unknown => assert(!x, msg);
+    const assertFn = positive ? assert : (value: unknown, msg?: string): unknown => assert(!value, msg);
 
     // Check fn to call
     if (fn === 'fail') {
@@ -102,36 +102,36 @@ export class AssertCheck {
 
       // Pushing on not error
       AssertCapture.add(assertion);
-    } catch (err) {
+    } catch (error) {
       // On error, produce the appropriate error message
-      if (err instanceof assert.AssertionError) {
+      if (error instanceof assert.AssertionError) {
         if (!assertion.message) {
           assertion.message = (OP_MAPPING[fn] ?? '{state} be {expected}');
         }
         assertion.message = assertion.message
-          .replace(/[{]([A-Za-z]+)[}]/g, (a, k: StringFields<Assertion>) => common[k] || assertion[k]!)
+          .replace(/[{]([A-Za-z]+)[}]/g, (a, key: StringFields<Assertion>) => common[key] || assertion[key]!)
           .replace(/not not/g, ''); // Handle double negatives
-        assertion.error = err;
-        err.message = assertion.message;
+        assertion.error = error;
+        error.message = assertion.message;
         AssertCapture.add(assertion);
       }
-      throw err;
+      throw error;
     }
   }
 
   /**
    * Check a given error
    * @param shouldThrow  Should the test throw anything
-   * @param err The provided error
+   * @param error The provided error
    */
-  static checkError(shouldThrow: ThrowableError | undefined, err: Error | string | undefined): Error | undefined {
+  static checkError(shouldThrow: ThrowableError | undefined, error: Error | string | undefined): Error | undefined {
     if (!shouldThrow) { // If we shouldn't be throwing anything, we are good
       return;
-    } else if (!err) {
+    } else if (!error) {
       return new assert.AssertionError({ message: 'Expected to throw an error, but got nothing' });
     } else if (typeof shouldThrow === 'string') {
-      if (!(err instanceof Error ? err.message : err).includes(shouldThrow)) {
-        const actual = err instanceof Error ? `'${err.message}'` : `'${err}'`;
+      if (!(error instanceof Error ? error.message : error).includes(shouldThrow)) {
+        const actual = error instanceof Error ? `'${error.message}'` : `'${error}'`;
         return new assert.AssertionError({
           message: `Expected error containing text '${shouldThrow}', but got ${actual}`,
           actual,
@@ -139,8 +139,8 @@ export class AssertCheck {
         });
       }
     } else if (shouldThrow instanceof RegExp) {
-      if (!shouldThrow.test(typeof err === 'string' ? err : err.message)) {
-        const actual = err instanceof Error ? `'${err.message}'` : `'${err}'`;
+      if (!shouldThrow.test(typeof error === 'string' ? error : error.message)) {
+        const actual = error instanceof Error ? `'${error.message}'` : `'${error}'`;
         return new assert.AssertionError({
           message: `Expected error with message matching '${shouldThrow.source}', but got ${actual}`,
           actual,
@@ -148,27 +148,27 @@ export class AssertCheck {
         });
       }
     } else if (isClass(shouldThrow)) {
-      if (!(err instanceof shouldThrow)) {
+      if (!(error instanceof shouldThrow)) {
         return new assert.AssertionError({
-          message: `Expected to throw ${shouldThrow.name}, but got ${err}`,
-          actual: (err ?? 'nothing'),
+          message: `Expected to throw ${shouldThrow.name}, but got ${error}`,
+          actual: (error ?? 'nothing'),
           expected: shouldThrow.name
         });
       }
     } else if (typeof shouldThrow === 'function') {
       const target = shouldThrow.name ? `("${shouldThrow.name}")` : '';
       try {
-        const res = shouldThrow(err);
-        if (res === false) {
-          return new assert.AssertionError({ message: `Checking function ${target} indicated an invalid error`, actual: err });
-        } else if (typeof res === 'string') {
-          return new assert.AssertionError({ message: res, actual: err });
+        const result = shouldThrow(error);
+        if (result === false) {
+          return new assert.AssertionError({ message: `Checking function ${target} indicated an invalid error`, actual: error });
+        } else if (typeof result === 'string') {
+          return new assert.AssertionError({ message: result, actual: error });
         }
-      } catch (checkErr) {
-        if (checkErr instanceof assert.AssertionError) {
-          return checkErr;
+      } catch (checkError) {
+        if (checkError instanceof assert.AssertionError) {
+          return checkError;
         } else {
-          return new assert.AssertionError({ message: `Checking function ${target} threw an error`, actual: checkErr });
+          return new assert.AssertionError({ message: `Checking function ${target} threw an error`, actual: checkError });
         }
       }
     }
@@ -177,26 +177,26 @@ export class AssertCheck {
   static #onError(
     positive: boolean,
     message: string | undefined,
-    err: unknown,
+    error: unknown,
     missed: Error | undefined,
     shouldThrow: ThrowableError | undefined,
     assertion: CaptureAssert
   ): void {
-    if (!(err instanceof Error)) {
-      err = new Error(`${err}`);
+    if (!(error instanceof Error)) {
+      error = new Error(`${error}`);
     }
-    if (!(err instanceof Error)) {
-      throw err;
+    if (!(error instanceof Error)) {
+      throw error;
     }
     if (positive) {
       missed = new assert.AssertionError({ message: 'Error thrown, but expected no errors' });
-      missed.stack = err.stack;
+      missed.stack = error.stack;
     }
 
-    const resolvedErr = (missed && err) ?? this.checkError(shouldThrow, err);
-    if (resolvedErr) {
-      assertion.message = message || missed?.message || resolvedErr.message;
-      throw (assertion.error = resolvedErr);
+    const resolvedError = (missed && error) ?? this.checkError(shouldThrow, error);
+    if (resolvedError) {
+      assertion.message = message || missed?.message || resolvedError.message;
+      throw (assertion.error = resolvedError);
     }
   }
 
@@ -225,8 +225,8 @@ export class AssertCheck {
         }
         throw (missed = new assert.AssertionError({ message: `No error thrown, but expected ${shouldThrow ?? 'an error'}`, expected: shouldThrow ?? 'an error' }));
       }
-    } catch (err) {
-      this.#onError(positive, message, err, missed, shouldThrow, assertion);
+    } catch (error) {
+      this.#onError(positive, message, error, missed, shouldThrow, assertion);
     } finally {
       AssertCapture.add(assertion);
     }
@@ -261,8 +261,8 @@ export class AssertCheck {
         }
         throw (missed = new assert.AssertionError({ message: `No error thrown, but expected ${shouldThrow ?? 'an error'}`, expected: shouldThrow ?? 'an error' }));
       }
-    } catch (err) {
-      this.#onError(positive, message, err, missed, shouldThrow, assertion);
+    } catch (error) {
+      this.#onError(positive, message, error, missed, shouldThrow, assertion);
     } finally {
       AssertCapture.add(assertion);
     }
@@ -271,8 +271,8 @@ export class AssertCheck {
   /**
    * Look for any unhandled exceptions
    */
-  static checkUnhandled(test: TestConfig, err: Error | assert.AssertionError): void {
-    let line = AssertUtil.getPositionOfError(err, test.sourceImport ?? test.import).line;
+  static checkUnhandled(test: TestConfig, error: Error | assert.AssertionError): void {
+    let line = AssertUtil.getPositionOfError(error, test.sourceImport ?? test.import).line;
     if (line === 1) {
       line = test.lineStart;
     }
@@ -281,9 +281,9 @@ export class AssertCheck {
       import: test.import,
       line,
       operator: 'throws',
-      error: err,
-      message: err.message,
-      text: ('operator' in err ? err.operator : '') || '(uncaught)'
+      error,
+      message: error.message,
+      text: ('operator' in error ? error.operator : '') || '(uncaught)'
     });
   }
 }

package/src/assert/util.ts

@@ -15,53 +15,53 @@ export class AssertUtil {
   /**
    * Clean a value for displaying in the output
    */
-  static cleanValue(val: unknown): unknown {
-    switch (typeof val) {
-      case 'number': case 'boolean': case 'bigint': case 'string': case 'undefined': return val;
+  static cleanValue(value: unknown): unknown {
+    switch (typeof value) {
+      case 'number': case 'boolean': case 'bigint': case 'string': case 'undefined': return value;
       case 'object': {
-        if (isCleanable(val)) {
-          return val.toClean();
-        } else if (val === null || val.constructor === Object || Array.isArray(val) || val instanceof Date) {
-          return JSON.stringify(val);
+        if (isCleanable(value)) {
+          return value.toClean();
+        } else if (value === null || value.constructor === Object || Array.isArray(value) || value instanceof Date) {
+          return JSON.stringify(value);
         }
         break;
       }
       case 'function': {
-        if (val.Ⲑid || !val.constructor) {
-          return val.name;
+        if (value.Ⲑid || !value.constructor) {
+          return value.name;
         }
         break;
       }
     }
-    return util.inspect(val, false, 1).replace(/\n/g, ' ');
+    return util.inspect(value, false, 1).replace(/\n/g, ' ');
   }
 
   /**
    * Determine file location for a given error and the stack trace
    */
-  static getPositionOfError(err: Error, imp: string): { import: string, line: number } {
-    const cwd = Runtime.mainSourcePath;
-    const lines = (err.stack ?? new Error().stack!)
+  static getPositionOfError(error: Error, importLocation: string): { import: string, line: number } {
+    const workingDirectory = Runtime.mainSourcePath;
+    const lines = (error.stack ?? new Error().stack!)
       .replace(/[\\/]/g, '/')
       .split('\n')
       // Exclude node_modules, target self
-      .filter(x => x.includes(cwd) && (!x.includes('node_modules') || x.includes('/support/')));
+      .filter(lineText => lineText.includes(workingDirectory) && (!lineText.includes('node_modules') || lineText.includes('/support/')));
 
-    const filename = RuntimeIndex.getFromImport(imp)?.sourceFile!;
+    const filename = RuntimeIndex.getFromImport(importLocation)?.sourceFile!;
 
-    let best = lines.filter(x => x.includes(filename))[0];
+    let best = lines.filter(lineText => lineText.includes(filename))[0];
 
     if (!best) {
-      [best] = lines.filter(x => x.includes(`${cwd}/test`));
+      [best] = lines.filter(lineText => lineText.includes(`${workingDirectory}/test`));
     }
 
     if (!best) {
-      return { import: imp, line: 1 };
+      return { import: importLocation, line: 1 };
     }
 
     const pth = best.trim().split(/\s+/g).slice(1).pop()!;
     if (!pth) {
-      return { import: imp, line: 1 };
+      return { import: importLocation, line: 1 };
     }
 
     const [file, lineNo] = pth
@@ -74,21 +74,21 @@ export class AssertUtil {
       line = -1;
     }
 
-    const outFileParts = file.split(cwd.replace(/^[A-Za-z]:/, ''));
+    const outFileParts = file.split(workingDirectory.replace(/^[A-Za-z]:/, ''));
 
     const outFile = outFileParts.length > 1 ? outFileParts[1].replace(/^[\/]/, '') : filename;
 
-    const res = { import: RuntimeIndex.getFromSource(outFile)?.import!, line };
+    const result = { import: RuntimeIndex.getFromSource(outFile)?.import!, line };
 
-    return res;
+    return result;
   }
 
   /**
    * Generate a suite error given a suite config, and an error
    */
   static generateSuiteFailure(suite: SuiteConfig, methodName: string, error: Error): SuiteFailure {
-    const { import: imp, ...pos } = this.getPositionOfError(error, suite.import);
-    let line = pos.line;
+    const { import: imp, ...rest } = this.getPositionOfError(error, suite.import);
+    let line = rest.line;
 
     if (line === 1 && suite.lineStart) {
       line = suite.lineStart;
@@ -96,7 +96,7 @@ export class AssertUtil {
 
     const msg = error.message.split(/\n/)[0];
 
-    const core = { import: imp, classId: suite.classId, methodName };
+    const core = { import: imp, classId: suite.classId, methodName, sourceHash: suite.sourceHash };
     const coreAll = { ...core, description: msg, lineStart: line, lineEnd: line, lineBodyStart: line };
 
     const assert: Assertion = {
@@ -118,13 +118,13 @@ export class AssertUtil {
   /**
    * Define import failure as a SuiteFailure object
    */
-  static gernerateImportFailure(imp: string, err: Error): SuiteFailure {
-    const name = path.basename(imp);
-    const classId = `${RuntimeIndex.getFromImport(imp)?.id}#${name}`;
+  static gernerateImportFailure(importLocation: string, error: Error): SuiteFailure {
+    const name = path.basename(importLocation);
+    const classId = `${RuntimeIndex.getFromImport(importLocation)?.id}#${name}`;
     const suite = asFull<SuiteConfig & SuiteResult>({
-      class: asFull<Class>({ name }), classId, duration: 0, lineStart: 1, lineEnd: 1, import: imp
+      class: asFull<Class>({ name }), classId, duration: 0, lineStart: 1, lineEnd: 1, import: importLocation
     });
-    err.message = err.message.replaceAll(Runtime.mainSourcePath, '.');
-    return this.generateSuiteFailure(suite, 'require', err);
+    error.message = error.message.replaceAll(Runtime.mainSourcePath, '.');
+    return this.generateSuiteFailure(suite, 'require', error);
   }
 }

package/src/communication.ts

@@ -0,0 +1,66 @@
+import { AppError, hasToJSON, JSONUtil } from '@travetto/runtime';
+
+/**
+ * Tools for communication serialization/deserialization especially with errors
+ */
+export class CommunicationUtil {
+
+  /**
+   * Serialize to JSON
+   */
+  static serialize<T>(out: T): string {
+    return JSON.stringify(out, function (key, value) {
+      const objectValue = this[key];
+      if (objectValue && objectValue instanceof Error) {
+        return {
+          $: true,
+          ...hasToJSON(objectValue) ? objectValue.toJSON() : objectValue,
+          name: objectValue.name,
+          message: objectValue.message,
+          stack: objectValue.stack,
+        };
+      } else if (typeof value === 'bigint') {
+        return `${value.toString()}$n`;
+      } else {
+        return value;
+      }
+    });
+  }
+
+  /**
+   * Serialize to a standard object, instead of a string
+   */
+  static serializeToObject<R = Record<string, unknown>, T = unknown>(out: T): R {
+    return JSONUtil.parseSafe(this.serialize(out));
+  }
+
+  /**
+   * Deserialize from JSON
+   */
+  static deserialize<T = unknown>(input: string): T {
+    return JSONUtil.parseSafe(input, function (key, value) {
+      if (value && typeof value === 'object' && '$' in value) {
+        const error = AppError.fromJSON(value) ?? new Error();
+        if (!(error instanceof AppError)) {
+          const { $: _, ...rest } = value;
+          Object.assign(error, rest);
+        }
+        error.message = value.message;
+        error.stack = value.stack;
+        error.name = value.name;
+        return error;
+      } else if (typeof value === 'string' && /^\d+[$]n$/.test(value)) {
+        return BigInt(value.split('$')[0]);
+      } else {
+        return value;
+      }
+    });
+  }
+
+  /**
+   * Deserialize from a standard object, instead of a string
+   */
+  static deserializeFromObject<R = unknown, T = R>(input: T): R {
+    return this.deserialize<R>(JSON.stringify(input));
+  }
+}

package/src/consumer/registry-index.ts

@@ -2,7 +2,7 @@ import { RuntimeIndex, type Class } from '@travetto/runtime';
 import { Registry, RegistryIndex, RegistryIndexStore } from '@travetto/registry';
 
 import type { TestConsumerShape } from './types.ts';
-import type { RunState } from '../execute/types.ts';
+import type { TestConsumerConfig } from '../execute/types.ts';
 import { TestConsumerRegistryAdapter } from './registry-adapter.ts';
 
 /**
@@ -25,33 +25,33 @@ export class TestConsumerRegistryIndex implements RegistryIndex {
 
   /**
    * Get a consumer instance that supports summarization
-   * @param consumer The consumer identifier or the actual consumer
+   * @param consumerConfig The consumer configuration
    */
-  static getInstance(state: Pick<RunState, 'consumer' | 'consumerOptions'>): Promise<TestConsumerShape> {
-    return this.#instance.getInstance(state);
+  static getInstance(consumerConfig: TestConsumerConfig): Promise<TestConsumerShape> {
+    return this.#instance.getInstance(consumerConfig);
   }
 
   #initialized: Promise<void>;
   store = new RegistryIndexStore(TestConsumerRegistryAdapter);
 
+  /** @private */ constructor(source: unknown) { Registry.validateConstructor(source); }
+
   /**
    * Manual initialization when running outside of the bootstrap process
    */
   async #init(): Promise<void> {
     const allFiles = RuntimeIndex.find({
-      module: m => m.name === '@travetto/test',
-      file: f => f.relativeFile.startsWith('src/consumer/types/')
+      module: mod => mod.name === '@travetto/test',
+      file: file => file.relativeFile.startsWith('src/consumer/types/')
     });
-    for (const f of allFiles) {
-      await import(f.outputFile);
+    for (const file of allFiles) {
+      await import(file.outputFile);
     }
     for (const cls of this.store.getClasses()) {
       this.store.finalize(cls);
     }
   }
 
-  process(): void { }
-
   /**
    * Get types
    */
@@ -69,7 +69,7 @@ export class TestConsumerRegistryIndex implements RegistryIndex {
    * Get a consumer instance that supports summarization
    * @param consumer The consumer identifier or the actual consumer
    */
-  async getInstance(state: Pick<RunState, 'consumer' | 'consumerOptions'>): Promise<TestConsumerShape> {
+  async getInstance(state: Pick<TestConsumerConfig, 'consumer' | 'consumerOptions'>): Promise<TestConsumerShape> {
     await (this.#initialized ??= this.#init());
     for (const cls of this.store.getClasses()) {
       const adapter = this.store.get(cls);