@travetto/test 5.0.0-rc.8 → 5.0.0-rc.9

package/package.json

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

package/src/assert/capture.ts

@@ -26,15 +26,15 @@ class $AssertCapture {
 
     // Emit and collect, every assertion as it occurs
     const handler = (a: CaptureAssert): void => {
-      const assrt: Assertion = {
+      const asrt: Assertion = {
         ...a,
         import: a.import ?? a.module!.join('/'),
         classId: test.classId,
         methodName: test.methodName
       };
-      assertions.push(assrt);
+      assertions.push(asrt);
       if (listener) {
-        listener(assrt);
+        listener(asrt);
       }
     };
 

package/src/assert/check.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert';
 
-import { AppError, ClassInstance, Class } from '@travetto/runtime';
+import { AppError, Class, castTo, castKey, asConstructable } from '@travetto/runtime';
 
 import { ThrowableError, TestConfig, Assertion } from '../model/test';
 import { AssertCapture, CaptureAssert } from './capture';
@@ -34,36 +34,35 @@ export class AssertCheck {
     // Invert check for negative
     const assertFn = positive ? assert : (x: unknown, msg?: string): unknown => assert(!x, msg);
 
-    /* eslint-disable @typescript-eslint/consistent-type-assertions */
     // Check fn to call
     if (fn === 'fail') {
       if (args.length > 1) {
-        [assertion.actual, assertion.expected, assertion.message, assertion.operator] = args as [unknown, unknown, string, string];
+        [assertion.actual, assertion.expected, assertion.message, assertion.operator] = castTo(args);
       } else {
-        [assertion.message] = args as [string];
+        [assertion.message] = castTo(args);
       }
     } else if (/throw|reject/i.test(fn)) {
       assertion.operator = fn;
       if (typeof args[1] !== 'string') {
-        [, assertion.expected, assertion.message] = args as [unknown, unknown, string];
+        [, assertion.expected, assertion.message] = castTo(args);
       } else {
-        [, assertion.message] = args as [unknown, string];
+        [, assertion.message] = castTo(args);
       }
     } else if (fn === 'ok' || fn === 'assert') {
       fn = assertion.operator = 'ok';
-      [assertion.actual, assertion.message] = args as [unknown, string];
+      [assertion.actual, assertion.message] = castTo(args);
       assertion.expected = { toClean: (): string => positive ? 'truthy' : 'falsy' };
       common.state = 'should be';
     } else if (fn === 'includes') {
       assertion.operator = fn;
-      [assertion.actual, assertion.expected, assertion.message] = args as [unknown, unknown, string];
+      [assertion.actual, assertion.expected, assertion.message] = castTo(args);
     } else if (fn === 'instanceof') {
       assertion.operator = fn;
-      [assertion.actual, assertion.expected, assertion.message] = args as [unknown, unknown, string];
-      assertion.actual = (assertion.actual as ClassInstance)?.constructor;
+      [assertion.actual, assertion.expected, assertion.message] = castTo(args);
+      assertion.actual = asConstructable(assertion.actual)?.constructor;
     } else { // Handle unknown
       assertion.operator = fn ?? '';
-      [assertion.actual, assertion.expected, assertion.message] = args as [unknown, unknown, string];
+      [assertion.actual, assertion.expected, assertion.message] = castTo(args);
     }
 
     try {
@@ -76,25 +75,25 @@ export class AssertCheck {
         assertion.expected = AssertUtil.cleanValue(assertion.expected);
       }
 
-      const [actual, expected, message] = args as [unknown, unknown, string];
+      const [actual, expected, message]: [unknown, unknown, string] = castTo(args);
 
       // Actually run the assertion
       switch (fn) {
-        case 'includes': assertFn((actual as unknown[]).includes(expected), message); break;
-        case 'test': assertFn((expected as RegExp).test(actual as string), message); break;
-        case 'instanceof': assertFn(actual instanceof (expected as Class), message); break;
-        case 'in': assertFn((actual as string) in (expected as object), message); break;
-        case 'lessThan': assertFn((actual as number) < (expected as number), message); break;
-        case 'lessThanEqual': assertFn((actual as number) <= (expected as number), message); break;
-        case 'greaterThan': assertFn((actual as number) > (expected as number), message); break;
-        case 'greaterThanEqual': assertFn((actual as number) >= (expected as number), message); break;
-        case 'ok': assertFn(...args as [unknown, string]); break;
+        case 'includes': assertFn(castTo<unknown[]>(actual).includes(expected), message); break;
+        case 'test': assertFn(castTo<RegExp>(expected).test(castTo(actual)), message); break;
+        case 'instanceof': assertFn(actual instanceof castTo<Class>(expected), message); break;
+        case 'in': assertFn(castTo<string>(actual) in castTo<object>(expected), message); break;
+        case 'lessThan': assertFn(castTo<number>(actual) < castTo<number>(expected), message); break;
+        case 'lessThanEqual': assertFn(castTo<number>(actual) <= castTo<number>(expected), message); break;
+        case 'greaterThan': assertFn(castTo<number>(actual) > castTo<number>(expected), message); break;
+        case 'greaterThanEqual': assertFn(castTo<number>(actual) >= castTo<number>(expected), message); break;
+        case 'ok': assertFn(...castTo<Parameters<typeof assertFn>>(args)); break;
         default:
-          if (fn && assert[fn as keyof typeof assert]) { // Assert call
+          if (fn && assert[castKey<typeof assert>(fn)]) { // Assert call
             if (/not/i.test(fn)) {
               common.state = 'should not';
             }
-            assert[fn as 'ok'].apply(null, args as [boolean, string | undefined]);
+            assert[castTo<'ok'>(fn)].apply(null, castTo(args));
           }
       }
 
@@ -115,7 +114,6 @@ export class AssertCheck {
       }
       throw err;
     }
-    /* eslint-enable @typescript-eslint/consistent-type-assertions */
   }
 
   /**

package/src/assert/util.ts

@@ -6,8 +6,7 @@ import { TestConfig, Assertion, TestResult } from '../model/test';
 import { SuiteConfig } from '../model/suite';
 
 function isCleanable(o: unknown): o is { toClean(): unknown } {
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  return !!o && !!(o as { toClean: unknown }).toClean;
+  return !!o && typeof o === 'object' && 'toClean' in o && typeof o.toClean === 'function';
 }
 
 /**
@@ -35,7 +34,6 @@ export class AssertUtil {
         break;
       }
     }
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return util.inspect(val, false, 1).replace(/\n/g, ' ');
   }
 

package/src/consumer/error.ts

@@ -14,9 +14,9 @@ export class ErrorUtil {
   /**
    *  Prepare error for transmission
    */
-  static serializeError(e: Error | SerializedError): SerializedError;
+  static serializeError(e: Error | SerializedError): Error;
   static serializeError(e: undefined): undefined;
-  static serializeError(e: Error | SerializedError | undefined): SerializedError | undefined {
+  static serializeError(e: Error | SerializedError | undefined): Error | undefined {
     let error: SerializedError | undefined;
 
     if (e) {
@@ -66,13 +66,11 @@ export class ErrorUtil {
     if (out.phase === 'after') {
       if (out.type === 'test') {
         if (out.test.error) {
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          out.test.error = this.serializeError(out.test.error) as Error;
+          out.test.error = this.serializeError(out.test.error);
         }
       } else if (out.type === 'assertion') {
         if (out.assertion.error) {
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          out.assertion.error = this.serializeError(out.assertion.error) as Error;
+          out.assertion.error = this.serializeError(out.assertion.error);
         }
       }
     }

package/src/consumer/registry.ts

@@ -1,4 +1,4 @@
-import type { Class, ConcreteClass } from '@travetto/runtime';
+import { classConstruct, type Class } from '@travetto/runtime';
 import { TestConsumer } from './types';
 
 /**
@@ -45,8 +45,7 @@ class $TestConsumerRegistry {
     await this.manualInit();
 
     return typeof consumer === 'string' ?
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      new ((this.get(consumer) ?? this.#primary) as ConcreteClass)() :
+      classConstruct(this.get(consumer) ?? this.#primary) :
       consumer;
   }
 }

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

@@ -30,7 +30,7 @@ export class TapStreamedEmitter implements TestConsumer {
     this.#consumer.onStart();
 
     let failed = 0;
-    const succ = StyleUtil.getStyle({ text: '#e5e5e5', background: '#026020' }); // White on dark green
+    const success = StyleUtil.getStyle({ text: '#e5e5e5', background: '#026020' }); // White on dark green
     const fail = StyleUtil.getStyle({ text: '#e5e5e5', background: '#8b0000' }); // White on dark red
     this.#progress = this.#terminal.streamToBottom(
       Util.mapAsyncItr(
@@ -39,7 +39,7 @@ export class TapStreamedEmitter implements TestConsumer {
           failed += (value.status === 'failed' ? 1 : 0);
           return { value: `Tests %idx/%total [${failed} failed] -- ${value.classId}`, total: state.testCount, idx };
         },
-        TerminalUtil.progressBarUpdater(this.#terminal, { style: () => ({ complete: failed ? fail : succ }) })
+        TerminalUtil.progressBarUpdater(this.#terminal, { style: () => ({ complete: failed ? fail : success }) })
       ),
       { minDelay: 100 }
     );

package/src/decorator/suite.ts

@@ -1,4 +1,4 @@
-import { Class, ClassInstance, describeFunction } from '@travetto/runtime';
+import { castTo, Class, ClassInstance, describeFunction } from '@travetto/runtime';
 
 import { SuiteRegistry } from '../registry/suite';
 import { SuiteConfig } from '../model/suite';
@@ -23,17 +23,16 @@ export function Suite(description?: string | Partial<SuiteConfig>, ...rest: Part
     Object.assign(extra, r);
   }
 
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  const decorator = ((target: Class) => {
+  const dec = (target: Class): typeof target => {
     const cfg = { description: descriptionString, ...extra };
     if (describeFunction(target).abstract) {
       cfg.skip = true;
     }
     SuiteRegistry.register(target, cfg);
     return target;
-  }) as ClassDecorator;
+  };
 
-  return decorator;
+  return castTo(dec);
 }
 
 function listener(phase: SuitePhase) {

package/src/execute/executor.ts

@@ -1,7 +1,7 @@
 import { AssertionError } from 'node:assert';
 import path from 'node:path';
 
-import { Env, TimeUtil, Runtime, RuntimeIndex } from '@travetto/runtime';
+import { Env, TimeUtil, Runtime, RuntimeIndex, castTo, asFull, Class } from '@travetto/runtime';
 import { Barrier, ExecutionError } from '@travetto/worker';
 
 import { SuiteRegistry } from '../registry/suite';
@@ -39,8 +39,7 @@ export class TestExecutor {
 
         try {
           await pCap.run(() =>
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            (suite.instance as Record<string, Function>)[test.methodName]()
+            castTo<Record<string, Function>>(suite.instance)[test.methodName]()
           );
         } finally {
           process.env = env; // Restore
@@ -68,8 +67,7 @@ export class TestExecutor {
   static failFile(consumer: TestConsumer, imp: string, err: Error): void {
     const name = path.basename(imp);
     const classId = `${RuntimeIndex.getFromImport(imp)?.id}￮${name}`;
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const suite = { class: { name }, classId, duration: 0, lineStart: 1, lineEnd: 1, import: imp, } as SuiteConfig & SuiteResult;
+    const suite = asFull<SuiteConfig & SuiteResult>({ class: asFull<Class>({ name }), classId, duration: 0, lineStart: 1, lineEnd: 1, import: imp, });
     err.message = err.message.replaceAll(Runtime.mainSourcePath, '.');
     const res = AssertUtil.generateSuiteError(suite, 'require', err);
     consumer.onEvent({ type: 'suite', phase: 'before', suite });
@@ -127,11 +125,11 @@ export class TestExecutor {
     }
 
     // Emit every assertion as it occurs
-    const getAssertions = AssertCapture.collector(test, assrt =>
+    const getAssertions = AssertCapture.collector(test, asrt =>
       consumer.onEvent({
         type: 'assertion',
         phase: 'after',
-        assertion: assrt
+        assertion: asrt
       })
     );
 

package/src/execute/promise.ts

@@ -1,4 +1,5 @@
 import { createHook, executionAsyncId } from 'node:async_hooks';
+import { isPromise } from 'node:util/types';
 
 import { ExecutionError } from '@travetto/worker';
 import { Util } from '@travetto/runtime';
@@ -11,9 +12,8 @@ export class PromiseCapturer {
   #id: number = 0;
 
   #init(id: number, type: string, triggerId: number, resource: unknown): void {
-    if (this.#id && type === 'PROMISE' && triggerId === this.#id) {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      this.#pending.set(id, resource as Promise<unknown>);
+    if (this.#id && type === 'PROMISE' && triggerId === this.#id && isPromise(resource)) {
+      this.#pending.set(id, resource);
     }
   }
 

package/src/registry/suite.ts

@@ -1,4 +1,4 @@
-import { Class, ConcreteClass, Runtime, describeFunction } from '@travetto/runtime';
+import { Class, Runtime, classConstruct, describeFunction, asFull } from '@travetto/runtime';
 import { MetadataRegistry } from '@travetto/registry';
 
 import { SuiteConfig } from '../model/suite';
@@ -57,8 +57,7 @@ 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 config = asFull(this.getOrCreatePending(cls));
     const tests = [...this.pendingFields.get(cls.Ⲑid)!.values()];
 
     const parent = this.getParentClass(cls);
@@ -75,10 +74,8 @@ class $SuiteRegistry extends MetadataRegistry<SuiteConfig, TestConfig> {
       })));
     }
 
-    // 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[];
+    config.instance = classConstruct(config.class);
+    config.tests = tests!.map(x => asFull(x));
 
     if (!config.description) {
       config.description = config.classId;

package/support/transformer.assert.ts

@@ -137,12 +137,12 @@ export class AssertTransformer {
    */
   static initState(state: TransformerState & AssertState): void {
     if (!state[AssertⲐ]) {
-      const assrt = state.importFile('@travetto/test/src/assert/check').ident;
+      const asrt = state.importFile('@travetto/test/src/assert/check').ident;
       state[AssertⲐ] = {
-        assert: assrt,
-        assertCheck: CoreUtil.createAccess(state.factory, assrt, ASSERT_UTIL, 'check'),
-        checkThrow: CoreUtil.createAccess(state.factory, assrt, ASSERT_UTIL, 'checkThrow'),
-        checkThrowAsync: CoreUtil.createAccess(state.factory, assrt, ASSERT_UTIL, 'checkThrowAsync'),
+        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'),
       };
     }
   }
@@ -153,7 +153,7 @@ export class AssertTransformer {
   static doAssert(state: TransformerState & AssertState, node: ts.CallExpression, cmd: Command): ts.CallExpression {
     this.initState(state);
 
-    const first = CoreUtil.getArgument<ts.CallExpression>(node);
+    const first = CoreUtil.firstArgument(node);
     const firstText = first!.getText();
 
     cmd.args = cmd.args.filter(x => x !== undefined && x !== null);
@@ -175,8 +175,8 @@ export class AssertTransformer {
    * Convert `assert.(throws|rejects|doesNotThrow|doesNotReject)` to the appropriate structure
    */
   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();
+    const first = CoreUtil.firstArgument(node)!;
+    const firstText = first.getText();
 
     this.initState(state);
     return state.factory.createCallExpression(