@travetto/test 5.0.0 → 5.0.1

package/package.json

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

package/src/assert/util.ts

@@ -1,14 +1,12 @@
 import util from 'node:util';
 import path from 'node:path';
 
-import { asFull, Class, Runtime, RuntimeIndex } from '@travetto/runtime';
+import { asFull, Class, hasFunction, Runtime, RuntimeIndex } from '@travetto/runtime';
 
 import { TestConfig, Assertion, TestResult } from '../model/test';
 import { SuiteConfig, SuiteFailure, SuiteResult } from '../model/suite';
 
-function isCleanable(o: unknown): o is { toClean(): unknown } {
-  return !!o && typeof o === 'object' && 'toClean' in o && typeof o.toClean === 'function';
-}
+const isCleanable = hasFunction<{ toClean(): unknown }>('toClean');
 
 /**
  * Assertion utilities

package/src/execute/barrier.ts

@@ -0,0 +1,100 @@
+import { isPromise } from 'node:util/types';
+import { createHook, executionAsyncId } from 'node:async_hooks';
+import { TimeSpan, TimeUtil, Util } from '@travetto/runtime';
+import { ExecutionError, TimeoutError } from './error';
+
+const UNCAUGHT_ERR_EVENTS = ['unhandledRejection', 'uncaughtException'] as const;
+
+export class Barrier {
+  /**
+   * Track timeout
+   */
+  static timeout(duration: number | TimeSpan, op: string = 'Operation'): { promise: Promise<void>, resolve: () => unknown } {
+    const resolver = Util.resolvablePromise();
+    const durationMs = TimeUtil.asMillis(duration);
+    let timeout: NodeJS.Timeout;
+    if (!durationMs) {
+      resolver.resolve();
+    } else {
+      const msg = `${op} timed out after ${duration}${typeof duration === 'number' ? 'ms' : ''}`;
+      timeout = setTimeout(() => resolver.reject(new TimeoutError(msg)), durationMs).unref();
+    }
+
+    resolver.promise.finally(() => { clearTimeout(timeout); });
+    return resolver;
+  }
+
+  /**
+   * Track uncaught error
+   */
+  static uncaughtErrorPromise(): { promise: Promise<void>, resolve: () => unknown } {
+    const uncaught = Util.resolvablePromise<void>();
+    const onError = (err: Error): void => { Util.queueMacroTask().then(() => uncaught.reject(err)); };
+    UNCAUGHT_ERR_EVENTS.map(k => process.on(k, onError));
+    uncaught.promise.finally(() => { UNCAUGHT_ERR_EVENTS.map(k => process.off(k, onError)); });
+    return uncaught;
+  }
+
+  /**
+   * Promise capturer
+   */
+  static capturePromises(): { start: () => Promise<void>, finish: () => Promise<void>, cleanup: () => void } {
+    const pending = new Map<number, Promise<unknown>>();
+    let id: number = 0;
+
+    const hook = createHook({
+      init(asyncId, type, triggerAsyncId, resource) {
+        if (id && type === 'PROMISE' && triggerAsyncId === id && isPromise(resource)) {
+          pending.set(id, resource);
+        }
+      },
+      promiseResolve(asyncId: number): void {
+        pending.delete(asyncId);
+      }
+    });
+
+    return {
+      async start(): Promise<void> {
+        hook.enable();
+        await Util.queueMacroTask();
+        id = executionAsyncId();
+      },
+      async finish(maxTaskCount = 5): Promise<void> {
+        let i = maxTaskCount; // Wait upto 5 macro tasks before continuing
+        while (pending.size) {
+          await Util.queueMacroTask();
+          i -= 1;
+          if (i === 0) {
+            throw new ExecutionError(`Pending promises: ${pending.size}`);
+          }
+        }
+      },
+      cleanup(): void {
+        hook.disable();
+      }
+    };
+  }
+
+  /**
+   * Wait for operation to finish, with timeout and unhandled error support
+   */
+  static async awaitOperation(timeout: number | TimeSpan, op: () => Promise<unknown>): Promise<Error | undefined> {
+    const uncaught = this.uncaughtErrorPromise();
+    const timer = this.timeout(timeout);
+    const promises = this.capturePromises();
+
+    try {
+      await promises.start();
+      let capturedError: Error | undefined;
+      const opProm = op().then(() => promises.finish());
+
+      await Promise.race([opProm, uncaught.promise, timer.promise]).catch(err => capturedError ??= err);
+
+      return capturedError;
+    } finally {
+      promises.cleanup();
+      timer.resolve();
+      uncaught.resolve();
+    }
+  }
+}

package/src/execute/error.ts

@@ -0,0 +1,11 @@
+import { AppError } from '@travetto/runtime';
+
+/**
+ * Represents an execution error
+ */
+export class ExecutionError extends AppError { }
+
+/**
+ * Timeout execution error
+ */
+export class TimeoutError extends ExecutionError { }

package/src/execute/executor.ts

@@ -1,7 +1,6 @@
 import { AssertionError } from 'node:assert';
 
 import { Env, TimeUtil, Runtime, castTo } from '@travetto/runtime';
-import { Barrier, ExecutionError } from '@travetto/worker';
 
 import { SuiteRegistry } from '../registry/suite';
 import { TestConfig, TestResult, TestRun } from '../model/test';
@@ -11,8 +10,9 @@ import { AssertCheck } from '../assert/check';
 import { AssertCapture } from '../assert/capture';
 import { ConsoleCapture } from './console';
 import { TestPhaseManager } from './phase';
-import { PromiseCapturer } from './promise';
 import { AssertUtil } from '../assert/util';
+import { Barrier } from './barrier';
+import { ExecutionError } from './error';
 
 const TEST_TIMEOUT = TimeUtil.fromValue(Env.TRV_TEST_TIMEOUT.val) ?? 5000;
 
@@ -22,11 +22,9 @@ const TEST_TIMEOUT = TimeUtil.fromValue(Env.TRV_TEST_TIMEOUT.val) ?? 5000;
 export class TestExecutor {
 
   #consumer: TestConsumer;
-  #testFilter: (config: TestConfig) => boolean;
 
-  constructor(consumer: TestConsumer, testFilter?: (config: TestConfig) => boolean) {
+  constructor(consumer: TestConsumer) {
     this.#consumer = consumer;
-    this.#testFilter = testFilter || ((): boolean => true);
   }
 
   /**
@@ -60,33 +58,21 @@ export class TestExecutor {
     const suite = SuiteRegistry.get(test.class);
 
     // Ensure all the criteria below are satisfied before moving forward
-    const barrier = new Barrier(test.timeout || TEST_TIMEOUT, true)
-      .add(async () => {
-        const env = process.env;
-        process.env = { ...env }; // Created an isolated environment
-        const pCap = new PromiseCapturer();
-
-        try {
-          await pCap.run(() =>
-            castTo<Record<string, Function>>(suite.instance)[test.methodName]()
-          );
-        } finally {
-          process.env = env; // Restore
-        }
-      });
-
-    // Wait for all barriers to be satisfied
-    return barrier.wait();
+    return Barrier.awaitOperation(test.timeout || TEST_TIMEOUT, async () => {
+      const env = process.env;
+      process.env = { ...env }; // Created an isolated environment
+      try {
+        await castTo<Record<string, Function>>(suite.instance)[test.methodName]();
+      } finally {
+        process.env = env; // Restore
+      }
+    });
   }
 
   /**
    * Determining if we should skip
    */
   async #shouldSkip(cfg: TestConfig | SuiteConfig, inst: unknown): Promise<boolean | undefined> {
-    if ('methodName' in cfg && !this.#testFilter(cfg)) {
-      return true;
-    }
-
     if (typeof cfg.skip === 'function' ? await cfg.skip(inst) : cfg.skip) {
       return true;
     }
@@ -269,6 +255,9 @@ export class TestExecutor {
 
     // Convert inbound arguments to specific tests to run
     const suites = SuiteRegistry.getSuiteTests(run);
+    if (!suites.length) {
+      console.warn('Unable to find suites for ', run);
+    }
 
     for (const { suite, tests } of suites) {
       await this.executeSuite(suite, tests);

package/src/execute/phase.ts

@@ -1,8 +1,8 @@
-import { Barrier } from '@travetto/worker';
 import { Env, TimeUtil } from '@travetto/runtime';
 
 import { SuiteConfig, SuiteFailure, SuiteResult } from '../model/suite';
 import { AssertUtil } from '../assert/util';
+import { Barrier } from './barrier';
 
 class TestBreakout extends Error {
   source?: Error;
@@ -35,9 +35,7 @@ export class TestPhaseManager {
     for (const fn of this.#suite[phase]) {
 
       // Ensure all the criteria below are satisfied before moving forward
-      error = await new Barrier(TEST_PHASE_TIMEOUT, true)
-        .add(async () => fn.call(this.#suite.instance))
-        .wait();
+      error = await Barrier.awaitOperation(TEST_PHASE_TIMEOUT, async () => fn.call(this.#suite.instance));
 
       if (error) {
         break;

package/src/execute/runner.ts

@@ -5,11 +5,11 @@ import { WorkPool } from '@travetto/worker';
 
 import { buildStandardTestManager } from '../worker/standard';
 import { RunnableTestConsumer } from '../consumer/types/runnable';
+import { TestRun } from '../model/test';
 
 import { TestExecutor } from './executor';
 import { RunnerUtil } from './util';
 import { RunState } from './types';
-import { TestConfig, TestRun } from '../model/test';
 
 /**
  * Test Runner
@@ -61,10 +61,6 @@ export class Runner {
       RuntimeIndex.reinitForModule(entry.module);
     }
 
-    const filter = (run.methodNames?.length) ?
-      (cfg: TestConfig): boolean => run.methodNames!.includes(cfg.methodName) :
-      undefined;
-
     const consumer = (await RunnableTestConsumer.get(this.#state.consumer ?? this.#state.format))
       .withTransformer(e => {
         // Copy run metadata to event
@@ -73,7 +69,7 @@ export class Runner {
       });
 
     await consumer.onStart({});
-    await new TestExecutor(consumer, filter).execute(run);
+    await new TestExecutor(consumer).execute(run);
     return consumer.summarizeAsBoolean();
   }
 

package/src/registry/suite.ts

@@ -119,7 +119,7 @@ class $SuiteRegistry extends MetadataRegistry<SuiteConfig, TestConfig> {
       } else if (clsId) {
         const cls = this.getValidClasses().find(x => x.Ⲑid === clsId)!;
         const suite = this.get(cls);
-        return [{ suite, tests: suite.tests }];
+        return suite ? [{ suite, tests: suite.tests }] : [];
       } else {
         const suites = this.getValidClasses()
           .map(x => this.get(x))

package/src/execute/promise.ts

@@ -1,49 +0,0 @@
-import { createHook, executionAsyncId } from 'node:async_hooks';
-import { isPromise } from 'node:util/types';
-
-import { ExecutionError } from '@travetto/worker';
-import { Util } from '@travetto/runtime';
-
-/**
- * Promise watcher, to catch any unfinished promises
- */
-export class PromiseCapturer {
-  #pending = new Map<number, Promise<unknown>>();
-  #id: number = 0;
-
-  #init(id: number, type: string, triggerId: number, resource: unknown): void {
-    if (this.#id && type === 'PROMISE' && triggerId === this.#id && isPromise(resource)) {
-      this.#pending.set(id, resource);
-    }
-  }
-
-  #promiseResolve(asyncId: number): void {
-    this.#pending.delete(asyncId);
-  }
-
-  async run(op: () => Promise<unknown> | unknown): Promise<unknown> {
-    const hook = createHook({
-      init: (...args) => this.#init(...args),
-      promiseResolve: (id) => this.#promiseResolve(id)
-    });
-
-    hook.enable();
-
-    await Util.queueMacroTask();
-    this.#id = executionAsyncId();
-    try {
-      const res = await op();
-      let i = 5; // Wait upto 5 macro tasks before continuing
-      while (this.#pending.size) {
-        await Util.queueMacroTask();
-        i -= 1;
-        if (i === 0) {
-          throw new ExecutionError(`Pending promises: ${this.#pending.size}`);
-        }
-      }
-      return res;
-    } finally {
-      hook.disable();
-    }
-  }
-}