jest-doctor 2.0.2 → 2.0.4

package/dist/patch/hook.js

@@ -4,15 +4,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const analyzeCallback_1 = __importDefault(require("../utils/analyzeCallback"));
+const getStack_1 = __importDefault(require("../utils/getStack"));
 const patchHook = (that, hookName, runtimeGlobals) => {
     const originalHook = that.global[hookName];
     that.global[hookName] = runtimeGlobals[hookName] =
-        function (callback, timeout = that.testTimeout) {
+        function hookPatcher(callback, timeout = that.testTimeout) {
+            const trace = (0, getStack_1.default)(hookPatcher).split('\n')[1];
             const hookMock = function () {
                 if (hookName === 'afterEach') {
                     that.currentAfterEachCount -= 1;
                 }
-                return (0, analyzeCallback_1.default)(that, callback, this, timeout, true);
+                return (0, analyzeCallback_1.default)(that, callback, this, timeout, true, trace);
             };
             // unfortunately, jest types the return type as any
             // eslint-disable-next-line @typescript-eslint/no-unsafe-return

package/dist/patch/it.js

@@ -4,12 +4,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const analyzeCallback_1 = __importDefault(require("../utils/analyzeCallback"));
+const getStack_1 = __importDefault(require("../utils/getStack"));
 const patchIt = (that, runtimeGlobals) => {
     const originalIt = runtimeGlobals.it;
     const originalOnly = originalIt.only;
-    const createItPatch = (originalFn) => (testName, testFunction, timeout = that.testTimeout) => {
+    const createItPatch = (originalFn) => function itPatcher(testName, testFunction, timeout = that.testTimeout) {
+        const trace = (0, getStack_1.default)(itPatcher).split('\n')[1];
         const testHandler = function () {
-            return (0, analyzeCallback_1.default)(that, testFunction, this, timeout, false);
+            return (0, analyzeCallback_1.default)(that, testFunction, this, timeout, false, trace);
         };
         return originalFn(testName, testHandler, timeout + 1_000);
     };

package/dist/patch/promise.js

@@ -26,18 +26,23 @@ const patchPromise = (that) => {
     };
     const concurrencyFactory = (promises, method) => {
         promises.forEach((promise) => {
-            promise.untrack = true;
-        });
-        return OriginalPromise[method](promises).finally(() => {
-            promises.forEach((promise) => {
+            if (promise instanceof TrackedPromise) {
+                promise.untrack = true;
                 untrack(promise);
-            });
+            }
         });
+        return OriginalPromise[method](promises);
     };
     class TrackedPromise extends OriginalPromise {
         untrack;
         constructor(executor) {
             const promises = that.leakRecords.get(that.currentTestName)?.promises;
+            let resolver;
+            let rejecter;
+            super((resolve, reject) => {
+                resolver = resolve;
+                rejecter = reject;
+            });
             const innerExecutor = (resolve, reject) => {
                 const wrappedResolve = (value) => {
                     promises?.delete(this);
@@ -47,10 +52,16 @@ const patchPromise = (that) => {
                     promises?.delete(this);
                     reject(reason);
                 };
-                return executor(wrappedResolve, wrappedReject);
+                try {
+                    executor(wrappedResolve, wrappedReject);
+                }
+                catch (error) {
+                    wrappedReject(error);
+                }
             };
-            super(innerExecutor);
             track(this, TrackedPromise);
+            // @ts-expect-error constructor will run first
+            innerExecutor(resolver, rejecter);
         }
         then(onFulfilled, onRejected) {
             const promise = super.then(onFulfilled, onRejected);

package/dist/utils/analyzeCallback.d.ts

@@ -1,4 +1,4 @@
 import type { Circus } from '@jest/types';
 import type { JestDoctorEnvironment } from '../types';
-declare const analyzeCallback: (that: JestDoctorEnvironment, callback: Circus.TestFn, testContext: Circus.TestContext, timeout: number, isHook: boolean) => Promise<unknown>;
+declare const analyzeCallback: (that: JestDoctorEnvironment, callback: Circus.TestFn, testContext: Circus.TestContext, timeout: number, isHook: boolean, trace: string) => Promise<unknown>;
 export default analyzeCallback;

package/dist/utils/analyzeCallback.js

@@ -7,16 +7,17 @@ const node_async_hooks_1 = require("node:async_hooks");
 const initLeakRecord_1 = __importDefault(require("./initLeakRecord"));
 const cleanupAfterTest_1 = __importDefault(require("./cleanupAfterTest"));
 const reportLeaks_1 = __importDefault(require("./reportLeaks"));
-const getTimeoutError = (timeout, isHook) => {
+const getTimeoutError = (timeout, isHook, trace) => {
     const error = new Error();
     error.stack = [
         `Exceeded timeout of ${timeout}ms for a ${isHook ? 'hook' : 'test'}.`,
         `Add a timeout value to this test to increase the timeout, if this is a long-running test.`,
-        `\nSee https://jestjs.io/docs/api#testname-fn-timeout.`,
-    ].join(' ');
+        `See https://jestjs.io/docs/api#testname-fn-timeout.`,
+        trace,
+    ].join('\n');
     return error;
 };
-const analyzeCallback = async (that, callback, testContext, timeout, isHook) => {
+const analyzeCallback = async (that, callback, testContext, timeout, isHook, trace) => {
     const testName = that.global.expect.getState().currentTestName ||
         'unknown';
     const leakRecord = (0, initLeakRecord_1.default)(that, testName);
@@ -30,7 +31,7 @@ const analyzeCallback = async (that, callback, testContext, timeout, isHook) =>
             let isRejected = false;
             timerId = setTimeout(() => {
                 isRejected = true;
-                reject(getTimeoutError(timeout, isHook));
+                reject(getTimeoutError(timeout, isHook, trace));
             }, timeout);
             void Promise.resolve(that.asyncStorage.run(testName, () => callback.call(testContext)))
                 .then((returnValue) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jest-doctor",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "description": "Custom Jest environment that detects async leaks between tests, enforces test isolation, and prevents flaky failures in CI.",
   "license": "MIT",
   "author": "Stephan Dum",