jest-doctor 0.0.5 → 0.0.7

package/dist/createEnvMixin.d.ts

@@ -29,6 +29,14 @@ declare const createEnvMixin: <EnvironmentConstructor extends JestDoctorConstruc
             clearTimeout: typeof clearTimeout;
             setInterval: typeof setInterval;
             clearInterval: typeof clearInterval;
+            stdout: {
+                (buffer: Uint8Array | string, cb?: (err?: Error | null) => void): boolean;
+                (str: Uint8Array | string, encoding?: BufferEncoding, cb?: (err?: Error | null) => void): boolean;
+            };
+            stderr: {
+                (buffer: Uint8Array | string, cb?: (err?: Error | null) => void): boolean;
+                (str: Uint8Array | string, encoding?: BufferEncoding, cb?: (err?: Error | null) => void): boolean;
+            };
             console: {
                 log: (message?: any, ...optionalParams: any[]) => void;
                 info: (message?: any, ...optionalParams: any[]) => void;
@@ -53,9 +61,12 @@ declare const createEnvMixin: <EnvironmentConstructor extends JestDoctorConstruc
             fakeTimers: number;
             console: number;
             totalDelay: number;
+            processOutputs: number;
         };
         tearDownError?: Error;
         asyncIdToPromise: Map<number, Promise<unknown>>;
+        asyncRoot: number;
+        asyncIdToParentId: Map<number, number>;
         setup(): Promise<void>;
         handleEvent(event: unknown, state: unknown): Promise<void>;
         handleTestEvent: JestEnvironment["handleTestEvent"];

package/dist/createEnvMixin.js

@@ -12,8 +12,8 @@ const fakeTimers_1 = __importDefault(require("./patch/fakeTimers"));
 const consts_1 = require("./consts");
 const timers_1 = __importDefault(require("./patch/timers"));
 const it_1 = __importDefault(require("./patch/it"));
-const createAsyncHookDetector_1 = __importDefault(require("./utils/createAsyncHookDetector"));
-const createAsyncHookCleaner_1 = __importDefault(require("./utils/createAsyncHookCleaner"));
+const createAsyncHookDetector_1 = __importDefault(require("./patch/createAsyncHookDetector"));
+const createAsyncHookCleaner_1 = __importDefault(require("./patch/createAsyncHookCleaner"));
 const reportLeaks_1 = __importDefault(require("./utils/reportLeaks"));
 const cleanupAfterTest_1 = __importDefault(require("./utils/cleanupAfterTest"));
 const initLeakRecord_1 = __importDefault(require("./utils/initLeakRecord"));
@@ -22,6 +22,7 @@ const getAllAfterEach_1 = __importDefault(require("./utils/getAllAfterEach"));
 const normalizeOptions_1 = __importDefault(require("./utils/normalizeOptions"));
 const getReporterTmpDir_1 = __importDefault(require("./utils/getReporterTmpDir"));
 const promiseConcurrency_1 = __importDefault(require("./patch/promiseConcurrency"));
+const processOutput_1 = __importDefault(require("./patch/processOutput"));
 const createEnvMixin = (Environment) => {
     // @ts-expect-error strange ts rule where constructor arguments should be any[] where again TypeScript complains
     return class Base extends Environment {
@@ -39,6 +40,8 @@ const createEnvMixin = (Environment) => {
         aggregatedReport;
         tearDownError;
         asyncIdToPromise = new Map();
+        asyncRoot = 0;
+        asyncIdToParentId = new Map();
         constructor(config, context) {
             super(config, context);
             this.testPath = context.testPath.replace(/\W/g, '_');
@@ -49,8 +52,9 @@ const createEnvMixin = (Environment) => {
                 fakeTimers: 0,
                 console: 0,
                 totalDelay: 0,
+                processOutputs: 0,
             };
-            const tmpDir = (0, getReporterTmpDir_1.default)(config.projectConfig.reporters);
+            const tmpDir = (0, getReporterTmpDir_1.default)(config.projectConfig.reporters || config.globalConfig.reporters);
             this.reporterTmpDir = tmpDir
                 ? node_path_1.default.join(tmpDir, config.globalConfig.seed.toString(), this.testPath + 'json')
                 : '';
@@ -72,6 +76,9 @@ const createEnvMixin = (Environment) => {
             if (report.console) {
                 (0, console_1.default)(this, report.console);
             }
+            if (report.processOutputs) {
+                (0, processOutput_1.default)(this, report.processOutputs);
+            }
             if (report.promises) {
                 (0, promiseConcurrency_1.default)(this);
             }
@@ -94,19 +101,11 @@ const createEnvMixin = (Environment) => {
             else if (circusEvent.name === 'setup') {
                 this.asyncHookCleaner?.enable();
                 this.asyncHookDetector?.enable();
-                (0, it_1.default)(this);
-                (0, hook_1.default)(this, 'beforeEach');
-                (0, hook_1.default)(this, 'beforeAll');
-                (0, hook_1.default)(this, 'afterEach');
-                (0, hook_1.default)(this, 'afterAll');
-                Object.assign(circusEvent.runtimeGlobals, {
-                    it: this.global.it,
-                    test: this.global.test,
-                    beforeEach: this.global.beforeEach,
-                    beforeAll: this.global.beforeAll,
-                    afterEach: this.global.afterEach,
-                    afterAll: this.global.afterAll,
-                });
+                (0, it_1.default)(this, circusEvent.runtimeGlobals);
+                (0, hook_1.default)(this, 'beforeEach', circusEvent.runtimeGlobals);
+                (0, hook_1.default)(this, 'beforeAll', circusEvent.runtimeGlobals);
+                (0, hook_1.default)(this, 'afterEach', circusEvent.runtimeGlobals);
+                (0, hook_1.default)(this, 'afterAll', circusEvent.runtimeGlobals);
             }
             await super.handleEvent?.(circusEvent, circusState);
         }
@@ -135,6 +134,8 @@ const createEnvMixin = (Environment) => {
             }
             finally {
                 (0, cleanupAfterTest_1.default)(this, leakRecord, consts_1.MAIN_THREAD);
+                process.stdout.write = this.original.stdout;
+                process.stderr.write = this.original.stderr;
                 this.asyncHookCleaner?.disable();
                 // this is added here for safety reasons,
                 // because jest could abort and dont hit teardown event
@@ -143,6 +144,7 @@ const createEnvMixin = (Environment) => {
                     this.aggregatedReport.timers +
                     this.aggregatedReport.fakeTimers +
                     this.aggregatedReport.console +
+                    this.aggregatedReport.processOutputs +
                     this.aggregatedReport.totalDelay;
                 if (this.reporterTmpDir && hasLeak) {
                     // needs to be sync or will be terminated by jest when an error occurs

package/dist/env/jsdom.d.ts

@@ -7,6 +7,14 @@ declare const _default: {
             clearTimeout: typeof clearTimeout;
             setInterval: typeof setInterval;
             clearInterval: typeof clearInterval;
+            stdout: {
+                (buffer: Uint8Array | string, cb?: (err?: Error | null) => void): boolean;
+                (str: Uint8Array | string, encoding?: BufferEncoding, cb?: (err?: Error | null) => void): boolean;
+            };
+            stderr: {
+                (buffer: Uint8Array | string, cb?: (err?: Error | null) => void): boolean;
+                (str: Uint8Array | string, encoding?: BufferEncoding, cb?: (err?: Error | null) => void): boolean;
+            };
             console: {
                 log: (message?: any, ...optionalParams: any[]) => void;
                 info: (message?: any, ...optionalParams: any[]) => void;
@@ -31,9 +39,12 @@ declare const _default: {
             fakeTimers: number;
             console: number;
             totalDelay: number;
+            processOutputs: number;
         };
         tearDownError?: Error;
         asyncIdToPromise: Map<number, Promise<unknown>>;
+        asyncRoot: number;
+        asyncIdToParentId: Map<number, number>;
         setup(): Promise<void>;
         handleEvent(event: unknown, state: unknown): Promise<void>;
         handleTestEvent: import("@jest/environment").JestEnvironment["handleTestEvent"];

package/dist/env/node.d.ts

@@ -7,6 +7,14 @@ declare const _default: {
             clearTimeout: typeof clearTimeout;
             setInterval: typeof setInterval;
             clearInterval: typeof clearInterval;
+            stdout: {
+                (buffer: Uint8Array | string, cb?: (err?: Error | null) => void): boolean;
+                (str: Uint8Array | string, encoding?: BufferEncoding, cb?: (err?: Error | null) => void): boolean;
+            };
+            stderr: {
+                (buffer: Uint8Array | string, cb?: (err?: Error | null) => void): boolean;
+                (str: Uint8Array | string, encoding?: BufferEncoding, cb?: (err?: Error | null) => void): boolean;
+            };
             console: {
                 log: (message?: any, ...optionalParams: any[]) => void;
                 info: (message?: any, ...optionalParams: any[]) => void;
@@ -31,9 +39,12 @@ declare const _default: {
             fakeTimers: number;
             console: number;
             totalDelay: number;
+            processOutputs: number;
         };
         tearDownError?: Error;
         asyncIdToPromise: Map<number, Promise<unknown>>;
+        asyncRoot: number;
+        asyncIdToParentId: Map<number, number>;
         setup(): Promise<void>;
         handleEvent(event: unknown, state: unknown): Promise<void>;
         handleTestEvent: import("@jest/environment").JestEnvironment["handleTestEvent"];

package/dist/patch/console.d.ts

@@ -1,4 +1,3 @@
 import type { JestDoctorEnvironment, ConsoleOptions } from '../types';
-export declare const isIgnored: (message: string, ignorePatterns: ConsoleOptions["ignore"]) => boolean;
 declare const patchConsole: (that: JestDoctorEnvironment, consoleOptions: ConsoleOptions) => void;
 export default patchConsole;

package/dist/patch/console.js

@@ -3,30 +3,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isIgnored = void 0;
 const node_util_1 = require("node:util");
 const getStack_1 = __importDefault(require("../utils/getStack"));
-const isIgnored = (message, ignorePatterns) => {
-    return ignorePatterns.some((pattern) => {
-        if (typeof pattern === 'string') {
-            return message.includes(pattern);
-        }
-        return pattern.test(message);
-    });
-};
-exports.isIgnored = isIgnored;
+const isIgnored_1 = __importDefault(require("../utils/isIgnored"));
 const patchConsole = (that, consoleOptions) => {
     const env = that.global;
     for (const consoleMethod of consoleOptions.methods) {
         const originalMethod = env.console[consoleMethod].bind(env.console);
         env.console[consoleMethod] = (...args) => {
             const message = (0, node_util_1.format)(...args);
-            if (!(0, exports.isIgnored)(message, consoleOptions.ignore)) {
+            if (!(0, isIgnored_1.default)(message, consoleOptions.ignore)) {
                 that.leakRecords.get(that.currentTestName)?.console.push({
                     method: consoleMethod,
-                    stack: (0, getStack_1.default)(env.console[consoleMethod], 'Console.' + consoleMethod),
-                    testName: that.currentTestName,
-                    message,
+                    stack: (0, getStack_1.default)(env.console[consoleMethod]),
                 });
             }
             return originalMethod(...args);

package/dist/{utils → patch}/createAsyncHookCleaner.js

@@ -4,6 +4,7 @@ const node_async_hooks_1 = require("node:async_hooks");
 const createAsyncHookCleaner = (that) => {
     return (0, node_async_hooks_1.createHook)({
         promiseResolve(asyncId) {
+            that.asyncIdToParentId.delete(asyncId);
             const owner = that.promiseOwner.get(asyncId);
             if (!owner) {
                 return;

package/dist/{utils → patch}/createAsyncHookDetector.d.ts

@@ -1,3 +1,3 @@
-import type { JestDoctorEnvironment } from '../types';
+import { JestDoctorEnvironment } from '../types';
 declare const createAsyncHookDetector: (that: JestDoctorEnvironment) => import("async_hooks").AsyncHook;
 export default createAsyncHookDetector;

package/dist/patch/createAsyncHookDetector.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_async_hooks_1 = require("node:async_hooks");
+const getStack_1 = __importDefault(require("../utils/getStack"));
+const isIgnored_1 = __importDefault(require("../utils/isIgnored"));
+const createAsyncHookDetector = (that) => {
+    const init = (asyncId, type, parentAsyncId, resource) => {
+        if (type !== 'PROMISE') {
+            return;
+        }
+        that.asyncIdToParentId.set(asyncId, parentAsyncId);
+        const stack = (0, getStack_1.default)(init);
+        if (!(0, isIgnored_1.default)(stack, that.options.report.promises.ignore)) {
+            const owner = that.currentTestName;
+            that.promiseOwner.set(asyncId, owner);
+            const promise = resource;
+            that.asyncIdToPromise.set(asyncId, promise);
+            that.leakRecords.get(owner)?.promises.set(promise, {
+                stack,
+                asyncId,
+                parentAsyncId,
+            });
+        }
+    };
+    return (0, node_async_hooks_1.createHook)({ init });
+};
+exports.default = createAsyncHookDetector;

package/dist/patch/fakeTimers.d.ts

@@ -1,3 +1,3 @@
-import type { JestDoctorEnvironment } from '../types';
+import { JestDoctorEnvironment } from '../types';
 declare const patchFakeTimers: (that: JestDoctorEnvironment) => void;
 export default patchFakeTimers;

package/dist/patch/fakeTimers.js

@@ -3,8 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const node_console_1 = __importDefault(require("node:console"));
 const getStack_1 = __importDefault(require("../utils/getStack"));
+const isIgnored_1 = __importDefault(require("../utils/isIgnored"));
+const chalk_1 = __importDefault(require("chalk"));
 const patchFakeTimers = (that) => {
     const modernFakeTimers = that.fakeTimersModern;
     const fakeTimers = modernFakeTimers?._fakeTimers;
@@ -27,22 +28,28 @@ const patchFakeTimers = (that) => {
                     fakeTimeout?.delete(timerId);
                     callback();
                 }, delay);
-                fakeTimeout?.set(timerId, {
-                    type: 'fakeTimeout',
-                    delay: delay || 0,
-                    stack: (0, getStack_1.default)(that.global.setTimeout, 'setTimeout'),
-                    testName: that.currentTestName,
-                });
+                const stack = (0, getStack_1.default)(that.global.setTimeout);
+                if (!(0, isIgnored_1.default)(stack, that.options.report.fakeTimers.ignore)) {
+                    fakeTimeout?.set(timerId, {
+                        type: 'fakeTimeout',
+                        delay: delay || 0,
+                        stack,
+                    });
+                }
                 return timerId;
             };
             clock.setInterval = function (callback, delay) {
                 const intervalId = originalFakeSetInterval(callback, delay);
-                that.leakRecords.get(that.currentTestName)?.fakeTimers.set(intervalId, {
-                    type: 'fakeInterval',
-                    delay: delay || 0,
-                    stack: (0, getStack_1.default)(that.global.setInterval, 'setInterval'),
-                    testName: that.currentTestName,
-                });
+                const stack = (0, getStack_1.default)(that.global.setInterval);
+                if (!(0, isIgnored_1.default)(stack, that.options.report.fakeTimers.ignore)) {
+                    that.leakRecords
+                        .get(that.currentTestName)
+                        ?.fakeTimers.set(intervalId, {
+                        type: 'fakeInterval',
+                        delay: delay || 0,
+                        stack,
+                    });
+                }
                 return intervalId;
             };
             clock.clearTimeout = (timerId) => {
@@ -59,7 +66,7 @@ const patchFakeTimers = (that) => {
         };
     }
     else {
-        node_console_1.default.warn('Fake timers could not be mocked!');
+        that.original.stderr(chalk_1.default.yellow('\nFake timers could not be mocked!'));
     }
 };
 exports.default = patchFakeTimers;

package/dist/patch/hook.d.ts

@@ -1,3 +1,3 @@
-import type { JestDoctorEnvironment } from '../types';
-declare const patchHook: (that: JestDoctorEnvironment, hookName: string) => void;
+import { JestDoctorEnvironment, RuntimeGlobals } from '../types';
+declare const patchHook: (that: JestDoctorEnvironment, hookName: string, runtimeGlobals: RuntimeGlobals) => void;
 export default patchHook;

package/dist/patch/hook.js

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

package/dist/patch/it.d.ts

@@ -1,3 +1,3 @@
-import type { JestDoctorEnvironment } from '../types';
-declare const patchIt: (that: JestDoctorEnvironment) => void;
+import { JestDoctorEnvironment, RuntimeGlobals } from '../types';
+declare const patchIt: (that: JestDoctorEnvironment, runtimeGlobals: RuntimeGlobals) => void;
 export default patchIt;

package/dist/patch/it.js

@@ -4,25 +4,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const analyzeCallback_1 = __importDefault(require("../utils/analyzeCallback"));
-const node_console_1 = __importDefault(require("node:console"));
-const patchIt = (that) => {
-    const originalIt = that.global.it;
-    if (originalIt) {
-        const originalOnly = that.global.it.only;
-        const createItPatch = (originalFn) => (testName, testFunction, timeout) => {
-            const testHandler = function () {
-                return (0, analyzeCallback_1.default)(that, testFunction, this);
-            };
-            return originalFn(testName, testHandler, timeout);
+const patchIt = (that, runtimeGlobals) => {
+    const originalIt = runtimeGlobals.it;
+    const originalOnly = originalIt.only;
+    const createItPatch = (originalFn) => (testName, testFunction, timeout) => {
+        const testHandler = function () {
+            return (0, analyzeCallback_1.default)(that, testFunction, this);
         };
-        const itPatch = createItPatch(originalIt);
-        Object.assign(itPatch, originalIt);
-        that.global.it = that.global.test = itPatch;
-        that.global.it.concurrent = that.global.it;
-        that.global.it.only = createItPatch(originalOnly);
-    }
-    else {
-        node_console_1.default.warn('injectGlobal it is set to false, this will impact on leak detection!');
+        return originalFn(testName, testHandler, timeout);
+    };
+    const itPatch = createItPatch(originalIt);
+    const test = Object.assign(itPatch, originalIt, {
+        concurrent: itPatch,
+        only: createItPatch(originalOnly),
+    });
+    if (that.global.test) {
+        that.global.it = that.global.test = test;
     }
+    runtimeGlobals.it = runtimeGlobals.test = test;
 };
 exports.default = patchIt;

package/dist/patch/processOutput.d.ts

@@ -0,0 +1,3 @@
+import { type OutputOptions, JestDoctorEnvironment } from '../types';
+declare const patchProcessOutput: (that: JestDoctorEnvironment, outputOptions: OutputOptions) => void;
+export default patchProcessOutput;

package/dist/patch/processOutput.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getStack_1 = __importDefault(require("../utils/getStack"));
+const isIgnored_1 = __importDefault(require("../utils/isIgnored"));
+const patchProcessOutput = (that, outputOptions) => {
+    const createOutputPatch = (method) => {
+        const patch = (...args) => {
+            const stack = (0, getStack_1.default)(patch);
+            if (!stack.includes('node_modules/@jest/console')) {
+                const owner = that.currentTestName;
+                const message = args[0].toString();
+                if (!(0, isIgnored_1.default)(message, outputOptions.ignore)) {
+                    that.leakRecords.get(owner)?.processOutputs.push({
+                        method,
+                        stack,
+                    });
+                }
+            }
+            return that.original[method](...args);
+        };
+        return patch;
+    };
+    outputOptions.methods.forEach((method) => {
+        process[method].write = createOutputPatch(method);
+    });
+};
+exports.default = patchProcessOutput;

package/dist/patch/promiseConcurrency.js

@@ -1,32 +1,63 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const node_async_hooks_1 = require("node:async_hooks");
 const patchPromiseConcurrency = (that) => {
     const env = that.global;
+    const getRootIds = () => {
+        let triggerId = (0, node_async_hooks_1.executionAsyncId)();
+        const rootIds = [triggerId];
+        while (triggerId !== that.asyncRoot && triggerId) {
+            triggerId = that.asyncIdToParentId.get(triggerId);
+            rootIds.push(triggerId);
+        }
+        return rootIds;
+    };
+    const cleanPromise = (promises, promise, asyncId) => {
+        that.asyncIdToPromise.delete(asyncId);
+        that.promiseOwner.delete(asyncId);
+        that.asyncIdToParentId.delete(asyncId);
+        promises.delete(promise);
+    };
+    const removeChildPromises = (promises, concurrentPromises, rootIds) => {
+        if (promises) {
+            concurrentPromises.forEach((concurrentPromise) => {
+                const leak = promises.get(concurrentPromise);
+                if (leak) {
+                    let asyncId = leak.asyncId;
+                    // Promise.race, Promise.any and Promise.all will create a new Promise for every entry that needs to be deleted
+                    promises.forEach((childLeak, key) => {
+                        if (childLeak.parentAsyncId === asyncId) {
+                            cleanPromise(promises, key, childLeak.asyncId);
+                        }
+                    });
+                    let promiseToDelete = concurrentPromise;
+                    while (!rootIds.includes(asyncId) && asyncId) {
+                        const parentId = that.asyncIdToParentId.get(asyncId);
+                        cleanPromise(promises, promiseToDelete, asyncId);
+                        asyncId = parentId;
+                        promiseToDelete = that.asyncIdToPromise.get(asyncId);
+                    }
+                }
+            });
+        }
+    };
     const concurrencyFactor = (fn) => (concurrentPromises) => {
         const promises = that.leakRecords.get(that.currentTestName)?.promises;
+        const rootIds = getRootIds();
         return fn(concurrentPromises).finally(() => {
-            if (promises) {
-                concurrentPromises.forEach((concurrentPromise) => {
-                    const leak = promises.get(concurrentPromise);
-                    if (leak) {
-                        const asyncId = leak?.asyncId;
-                        that.asyncIdToPromise.delete(asyncId);
-                        that.promiseOwner.delete(asyncId);
-                        promises.delete(concurrentPromise);
-                        // Promise.race and Promise.any will create a new Promise for every entry that needs to be deleted
-                        promises.forEach((childLeak, key) => {
-                            if (childLeak.parentAsyncId === asyncId) {
-                                that.asyncIdToPromise.delete(childLeak.asyncId);
-                                that.promiseOwner.delete(childLeak.asyncId);
-                                promises.delete(key);
-                            }
-                        });
-                    }
-                });
-            }
+            removeChildPromises(promises, concurrentPromises, rootIds);
         });
     };
     env.Promise.race = concurrencyFactor(env.Promise.race.bind(env.Promise));
     env.Promise.any = concurrencyFactor(env.Promise.any.bind(env.Promise));
+    const originalPromiseAll = env.Promise.all.bind(env.Promise);
+    env.Promise.all = (concurrentPromises) => {
+        const promises = that.leakRecords.get(that.currentTestName)?.promises;
+        const rootIds = getRootIds();
+        return originalPromiseAll(concurrentPromises).catch((error) => {
+            removeChildPromises(promises, concurrentPromises, rootIds);
+            throw error;
+        });
+    };
 };
 exports.default = patchPromiseConcurrency;

package/dist/patch/timers.d.ts

@@ -1,3 +1,3 @@
-import type { JestDoctorEnvironment } from '../types';
+import { JestDoctorEnvironment } from '../types';
 declare const timers: (that: JestDoctorEnvironment) => void;
 export default timers;

package/dist/patch/timers.js

@@ -5,13 +5,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const getStack_1 = __importDefault(require("../utils/getStack"));
 const consts_1 = require("../consts");
+const isIgnored_1 = __importDefault(require("../utils/isIgnored"));
 const timers = (that) => {
     const env = that.global;
+    const report = that.options.report;
     env.setTimeout = Object.assign(function (callback, delay) {
         const owner = that.currentTestName;
         const leakRecord = that.leakRecords.get(owner);
+        const stack = (0, getStack_1.default)(env.setTimeout);
+        const isAllowed = report.timers && !(0, isIgnored_1.default)(stack, report.timers.ignore);
         const timerId = that.original.setTimeout(() => {
-            if (leakRecord) {
+            if (leakRecord && isAllowed) {
                 if (owner !== consts_1.MAIN_THREAD && delay) {
                     leakRecord.totalDelay += delay;
                 }
@@ -22,27 +26,27 @@ const timers = (that) => {
         leakRecord?.timers.set(timerId, {
             type: 'timeout',
             delay: delay || 0,
-            stack: (0, getStack_1.default)(env.setTimeout, 'fake setTimeout'),
-            testName: owner,
+            stack,
+            isAllowed,
         });
         return timerId;
     }, that.original.setTimeout);
     env.setInterval = Object.assign(function (callback, delay) {
         const owner = that.currentTestName;
+        const leakRecord = that.leakRecords.get(owner);
+        const stack = (0, getStack_1.default)(env.setInterval);
+        const isAllowed = report.timers && !(0, isIgnored_1.default)(stack, report.timers.ignore);
         const intervalId = that.original.setInterval(() => {
-            if (owner !== consts_1.MAIN_THREAD && delay) {
-                const leakRecord = that.leakRecords.get(owner);
-                if (leakRecord) {
-                    leakRecord.totalDelay += delay;
-                }
+            if (isAllowed && owner !== consts_1.MAIN_THREAD && delay && leakRecord) {
+                leakRecord.totalDelay += delay;
             }
             callback();
         }, delay);
         that.leakRecords.get(owner)?.timers.set(intervalId, {
             type: 'interval',
             delay: delay || 0,
-            stack: (0, getStack_1.default)(env.setInterval, 'fake setInterval'),
-            testName: that.currentTestName,
+            isAllowed,
+            stack,
         });
         return intervalId;
     }, that.original.setInterval);