@travetto/test 5.0.14 → 5.0.15

package/README.md

@@ -208,7 +208,7 @@ class SimpleTest {
     await assert.rejects(() => {
       throw new Error('Big Error');
     }, (err: Error) =>
-      err.message.startsWith('Big') && err.message.length > 4 ? undefined : err
+      err.message.startsWith('Big') && err.message.length > 4
     );
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/test",
-  "version": "5.0.14",
+  "version": "5.0.15",
   "description": "Declarative test framework",
   "keywords": [
     "unit-testing",
@@ -27,14 +27,14 @@
     "directory": "module/test"
   },
   "dependencies": {
-    "@travetto/registry": "^5.0.12",
-    "@travetto/runtime": "^5.0.12",
-    "@travetto/terminal": "^5.0.14",
-    "@travetto/worker": "^5.0.14",
+    "@travetto/registry": "^5.0.13",
+    "@travetto/runtime": "^5.0.13",
+    "@travetto/terminal": "^5.0.15",
+    "@travetto/worker": "^5.0.15",
     "yaml": "^2.6.0"
   },
   "peerDependencies": {
-    "@travetto/cli": "^5.0.15",
+    "@travetto/cli": "^5.0.16",
     "@travetto/transformer": "^5.0.10"
   },
   "peerDependenciesMeta": {

package/src/assert/check.ts

@@ -1,4 +1,5 @@
 import assert from 'node:assert';
+import { isPromise } from 'node:util/types';
 
 import { AppError, Class, castTo, castKey, asConstructable } from '@travetto/runtime';
 
@@ -12,6 +13,8 @@ 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);
+
 /**
  * Check assertion
  */
@@ -124,46 +127,48 @@ export class AssertCheck {
   static checkError(shouldThrow: ThrowableError | undefined, err: Error | string | undefined): Error | undefined {
     if (!shouldThrow) { // If we shouldn't be throwing anything, we are good
       return;
-    }
-    // If should throw is a string or a regexp
-    if (typeof shouldThrow === 'string' || shouldThrow instanceof RegExp) {
-      const actual = `${err instanceof Error ? `'${err.message}'` : (err ? `'${err}'` : 'nothing')}`;
-
-      // If a string, check if error exists, and then see if the string is included in the message
-      if (typeof shouldThrow === 'string' && (!err || !(err instanceof Error ? err.message : err).includes(shouldThrow))) {
+    } else if (!err) {
+      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}'`;
         return new assert.AssertionError({
           message: `Expected error containing text '${shouldThrow}', but got ${actual}`,
           actual,
           expected: shouldThrow
         });
       }
-      // If a regexp, check if error exists, and then test the error message against the regex
-      if (shouldThrow instanceof RegExp && (!err || !shouldThrow.test(typeof err === 'string' ? err : err.message))) {
+    } else if (shouldThrow instanceof RegExp) {
+      if (!shouldThrow.test(typeof err === 'string' ? err : err.message)) {
+        const actual = err instanceof Error ? `'${err.message}'` : `'${err}'`;
         return new assert.AssertionError({
           message: `Expected error with message matching '${shouldThrow.source}', but got ${actual}`,
           actual,
           expected: shouldThrow.source
         });
       }
-      // If passing in a constructor
-    } else if (shouldThrow === Error ||
-      shouldThrow === AppError ||
-      Object.getPrototypeOf(shouldThrow) !== Object.getPrototypeOf(Function)
-    ) { // if not simple function, treat as class
-      if (!err || !(err instanceof shouldThrow)) {
+    } else if (isClass(shouldThrow)) {
+      if (!(err instanceof shouldThrow)) {
         return new assert.AssertionError({
-          message: `Expected to throw ${shouldThrow.name}, but got ${err ?? 'nothing'}`,
+          message: `Expected to throw ${shouldThrow.name}, but got ${err}`,
           actual: (err ?? 'nothing'),
           expected: shouldThrow.name
         });
       }
-    } else {
-      // Else treat as a simple function to build an error or not
-      const res = shouldThrow(err);
-      if (res && !(res instanceof Error)) {
-        return new AppError(`Invalid check, "${shouldThrow.name}" should return an Error or undefined`, { category: 'data' });
-      } else {
-        return res;
+    } else if (typeof shouldThrow === 'function') {
+      try {
+        const res = shouldThrow(err);
+        if (res === false) {
+          return new assert.AssertionError({ message: `Checking "${shouldThrow.name}" indicated an invalid error`, actual: err });
+        } else if (typeof res === 'string') {
+          return new assert.AssertionError({ message: res, actual: err });
+        }
+      } catch (checkErr) {
+        if (checkErr instanceof assert.AssertionError) {
+          return checkErr;
+        } else {
+          return new assert.AssertionError({ message: `Checking "${shouldThrow.name}" threw an error`, actual: checkErr });
+        }
       }
     }
   }
@@ -171,7 +176,8 @@ export class AssertCheck {
   static #onError(
     positive: boolean,
     message: string | undefined,
-    err: unknown, missed: Error | undefined,
+    err: unknown,
+    missed: Error | undefined,
     shouldThrow: ThrowableError | undefined,
     assertion: CaptureAssert
   ): void {
@@ -182,7 +188,7 @@ export class AssertCheck {
       throw err;
     }
     if (positive) {
-      missed = new AppError('Error thrown, but expected no errors');
+      missed = new assert.AssertionError({ message: 'Error thrown, but expected no errors' });
       missed.stack = err.stack;
     }
 
@@ -216,7 +222,7 @@ export class AssertCheck {
         if (typeof shouldThrow === 'function') {
           shouldThrow = shouldThrow.name;
         }
-        throw (missed = new AppError(`No error thrown, but expected ${shouldThrow ?? 'an error'}`));
+        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);
@@ -243,7 +249,7 @@ export class AssertCheck {
     let missed: Error | undefined;
 
     try {
-      if ('then' in action) {
+      if (isPromise(action)) {
         await action;
       } else {
         await action();
@@ -252,7 +258,7 @@ export class AssertCheck {
         if (typeof shouldThrow === 'function') {
           shouldThrow = shouldThrow.name;
         }
-        throw (missed = new AppError(`No error thrown, but expected ${shouldThrow ?? 'an error'} `));
+        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);

package/src/decorator/test.ts

@@ -1,7 +1,7 @@
 import { ClassInstance } from '@travetto/runtime';
 
 import { SuiteRegistry } from '../registry/suite';
-import { TestConfig } from '../model/test';
+import { TestConfig, ThrowableError } from '../model/test';
 
 /**
  * The `@AssertCheck` indicates that a function's assert calls should be transformed
@@ -39,7 +39,7 @@ export function Test(description?: string | Partial<TestConfig>, ...rest: Partia
  * Marks a method as should throw to indicate a lack of throwing is a problem
  * @param state The parameters to use for checking if the response is valid
  */
-export function ShouldThrow(state: TestConfig['shouldThrow']): MethodDecorator {
+export function ShouldThrow(state: ThrowableError): MethodDecorator {
   return (inst: ClassInstance, prop: string | symbol, descriptor: PropertyDescriptor) => {
     SuiteRegistry.registerField(inst.constructor, descriptor.value, { shouldThrow: state });
     return descriptor;

package/src/model/test.ts

@@ -1,7 +1,7 @@
 import type { Class, TimeSpan } from '@travetto/runtime';
 import { Skip, TestCore } from './common';
 
-export type ThrowableError = string | RegExp | Function;
+export type ThrowableError = string | RegExp | Class<Error> | ((e: Error | string) => boolean | void | undefined);
 
 /**
  * Specific configuration for a test