jest-doctor 0.0.3 → 0.0.4

package/dist/createEnvMixin.d.ts

@@ -55,6 +55,7 @@ declare const createEnvMixin: <EnvironmentConstructor extends JestDoctorConstruc
             totalDelay: number;
         };
         tearDownError?: Error;
+        asyncIdToPromise: Map<number, Promise<unknown>>;
         setup(): Promise<void>;
         handleEvent(event: unknown, state: unknown): Promise<void>;
         handleTestEvent: JestEnvironment["handleTestEvent"];

package/dist/createEnvMixin.js

@@ -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 promise_1 = __importDefault(require("./patch/promise"));
+const promiseConcurrency_1 = __importDefault(require("./patch/promiseConcurrency"));
 const createEnvMixin = (Environment) => {
     // @ts-expect-error strange ts rule where constructor arguments should be any[] where again TypeScript complains
     return class Base extends Environment {
@@ -38,6 +39,7 @@ const createEnvMixin = (Environment) => {
         testPath;
         aggregatedReport;
         tearDownError;
+        asyncIdToPromise = new Map();
         constructor(config, context) {
             super(config, context);
             this.testPath = context.testPath.replace(/\W/g, '_');
@@ -72,8 +74,11 @@ const createEnvMixin = (Environment) => {
             if (report.console) {
                 (0, console_1.default)(this, report.console);
             }
-            if (report.promises && report.promises.patch === 'promise') {
-                (0, promise_1.default)(this);
+            if (report.promises) {
+                (0, promiseConcurrency_1.default)(this);
+                if (report.promises.patch === 'promise') {
+                    (0, promise_1.default)(this);
+                }
             }
         }
         // unfortunately @jest/types doesn't export the necessary types,

package/dist/env/jsdom.d.ts

@@ -33,6 +33,7 @@ declare const _default: {
             totalDelay: number;
         };
         tearDownError?: Error;
+        asyncIdToPromise: Map<number, Promise<unknown>>;
         setup(): Promise<void>;
         handleEvent(event: unknown, state: unknown): Promise<void>;
         handleTestEvent: import("@jest/environment").JestEnvironment["handleTestEvent"];

package/dist/env/node.d.ts

@@ -33,6 +33,7 @@ declare const _default: {
             totalDelay: number;
         };
         tearDownError?: Error;
+        asyncIdToPromise: Map<number, Promise<unknown>>;
         setup(): Promise<void>;
         handleEvent(event: unknown, state: unknown): Promise<void>;
         handleTestEvent: import("@jest/environment").JestEnvironment["handleTestEvent"];

package/dist/patch/console.js

@@ -24,7 +24,7 @@ const patchConsole = (that, consoleOptions) => {
             if (!(0, exports.isIgnored)(message, consoleOptions.ignore)) {
                 that.leakRecords.get(that.currentTestName)?.console.push({
                     method: consoleMethod,
-                    stack: (0, getStack_1.default)(env.console[consoleMethod]),
+                    stack: (0, getStack_1.default)(env.console[consoleMethod], 'Console.' + consoleMethod),
                     testName: that.currentTestName,
                     message,
                 });

package/dist/patch/fakeTimers.js

@@ -30,7 +30,7 @@ const patchFakeTimers = (that) => {
                 fakeTimeout?.set(timerId, {
                     type: 'fakeTimeout',
                     delay: delay || 0,
-                    stack: (0, getStack_1.default)(that.global.setTimeout),
+                    stack: (0, getStack_1.default)(that.global.setTimeout, 'setTimeout'),
                     testName: that.currentTestName,
                 });
                 return timerId;
@@ -40,7 +40,7 @@ const patchFakeTimers = (that) => {
                 that.leakRecords.get(that.currentTestName)?.fakeTimers.set(intervalId, {
                     type: 'fakeInterval',
                     delay: delay || 0,
-                    stack: (0, getStack_1.default)(that.global.setInterval),
+                    stack: (0, getStack_1.default)(that.global.setInterval, 'setInterval'),
                     testName: that.currentTestName,
                 });
                 return intervalId;

package/dist/patch/promise.js

@@ -17,7 +17,7 @@ const patchPromise = (that) => {
             const promiseLeaks = that.leakRecords.get(that.currentTestName)?.promises;
             promiseLeaks?.set(this, {
                 testName: that.currentTestName,
-                stack: (0, getStack_1.default)(that.global.Promise),
+                stack: (0, getStack_1.default)(that.global.Promise, 'Promise'),
             });
             executor((value) => {
                 promiseLeaks?.delete(this);

package/dist/patch/promiseConcurrency.d.ts

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

package/dist/patch/promiseConcurrency.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const patchPromiseConcurrency = (that) => {
+    const env = that.global;
+    const concurrencyFactor = (fn) => (concurrentPromises) => {
+        const promises = that.leakRecords.get(that.currentTestName)?.promises;
+        // remove all related promises is a concurrent promise ends
+        const removePromises = () => {
+            if (promises) {
+                concurrentPromises.forEach((racePromise) => {
+                    promises.delete(racePromise);
+                });
+            }
+        };
+        return fn(concurrentPromises).then((returnValues) => {
+            removePromises();
+            return returnValues;
+        }, (error) => {
+            removePromises();
+            throw error;
+        });
+    };
+    env.Promise.race = concurrencyFactor(env.Promise.race.bind(env.Promise));
+    env.Promise.any = concurrencyFactor(env.Promise.any.bind(env.Promise));
+};
+exports.default = patchPromiseConcurrency;

package/dist/patch/race.d.ts

@@ -0,0 +1 @@
+declare const patchRace: () => void;

package/dist/patch/race.js

@@ -0,0 +1,2 @@
+"use strict";
+const patchRace = () => { };

package/dist/patch/timers.js

@@ -22,7 +22,7 @@ const timers = (that) => {
         leakRecord?.timers.set(timerId, {
             type: 'timeout',
             delay: delay || 0,
-            stack: (0, getStack_1.default)(env.setTimeout),
+            stack: (0, getStack_1.default)(env.setTimeout, 'fake setTimeout'),
             testName: owner,
         });
         return timerId;
@@ -41,7 +41,7 @@ const timers = (that) => {
         that.leakRecords.get(owner)?.timers.set(intervalId, {
             type: 'interval',
             delay: delay || 0,
-            stack: (0, getStack_1.default)(env.setInterval),
+            stack: (0, getStack_1.default)(env.setInterval, 'fake setInterval'),
             testName: that.currentTestName,
         });
         return intervalId;

package/dist/reporter.js

@@ -15,7 +15,6 @@ const isAlive = (pid) => {
         return true;
     }
     catch (error) {
-        console.log(error.code);
         return error.code !== 'ESRCH';
     }
 };

package/dist/requireEnvironment.d.ts

@@ -34,6 +34,7 @@ declare const requireEnvironment: (envName: string) => {
             totalDelay: number;
         };
         tearDownError?: Error;
+        asyncIdToPromise: Map<number, Promise<unknown>>;
         setup(): Promise<void>;
         handleEvent(event: unknown, state: unknown): Promise<void>;
         handleTestEvent: import("@jest/environment").JestEnvironment["handleTestEvent"];

package/dist/types.d.ts

@@ -18,7 +18,7 @@ export interface ConsoleRecord {
     message: string;
 }
 export interface LeakRecord {
-    promises: Map<number | Promise<unknown>, PromiseRecord>;
+    promises: Map<Promise<unknown>, PromiseRecord>;
     timers: Map<NodeJS.Timeout, TimerRecord>;
     console: ConsoleRecord[];
     totalDelay: number;
@@ -58,6 +58,7 @@ export interface NormalizedOptions {
             patch: Patch;
         };
     };
+    verbose: boolean;
     delayThreshold: number;
     timerIsolation: TimerIsolation;
     clearTimers: boolean;
@@ -78,6 +79,7 @@ export interface RawOptions {
         fakeTimers?: OnError;
         promises?: RawPromise;
     };
+    verbose?: boolean;
     delayThreshold?: number;
     timerIsolation?: TimerIsolation;
     clearTimers?: boolean;
@@ -100,5 +102,6 @@ export interface JestDoctorEnvironment {
     currentAfterEachCount: number;
     options: NormalizedOptions;
     aggregatedReport: AggregatedReport;
+    asyncIdToPromise: Map<number, Promise<unknown>>;
 }
 export {};

package/dist/utils/createAsyncHookCleaner.js

@@ -7,8 +7,12 @@ const createAsyncHookCleaner = (that) => {
             const owner = that.promiseOwner.get(asyncId);
             if (!owner)
                 return;
-            that.leakRecords.get(owner)?.promises.delete(asyncId);
-            that.promiseOwner.delete(asyncId);
+            const promise = that.asyncIdToPromise.get(asyncId);
+            if (promise) {
+                that.leakRecords.get(owner)?.promises.delete(promise);
+                that.promiseOwner.delete(asyncId);
+                that.asyncIdToPromise.delete(asyncId);
+            }
         },
     });
 };

package/dist/utils/createAsyncHookDetector.js

@@ -6,13 +6,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const node_async_hooks_1 = require("node:async_hooks");
 const getStack_1 = __importDefault(require("./getStack"));
 const createAsyncHookDetector = (that) => {
-    const init = (asyncId, type) => {
+    const init = (asyncId, type, _, resource) => {
         if (type !== 'PROMISE')
             return;
+        const promise = resource;
         const owner = that.currentTestName;
         that.promiseOwner.set(asyncId, owner);
-        that.leakRecords.get(owner)?.promises.set(asyncId, {
-            stack: (0, getStack_1.default)(init),
+        that.asyncIdToPromise.set(asyncId, promise);
+        that.leakRecords.get(owner)?.promises.set(promise, {
+            stack: (0, getStack_1.default)(init, 'Promise'),
             testName: owner,
         });
     };

package/dist/utils/getStack.d.ts

@@ -1,2 +1,2 @@
-declare const getStack: (stackFrom: Function) => string;
+declare const getStack: (stackFrom: Function, prefix: string) => string;
 export default getStack;

package/dist/utils/getStack.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const getStack = (stackFrom) => {
+const getStack = (stackFrom, prefix) => {
     const error = {
         stack: '',
     };
     Error.captureStackTrace(error, stackFrom);
-    return error.stack;
+    return prefix + ' ' + error.stack;
 };
 exports.default = getStack;

package/dist/utils/normalizeOptions.js

@@ -15,6 +15,7 @@ const DEFAULTS = {
             patch: 'async_hooks',
         },
     },
+    verbose: false,
     delayThreshold: 0,
     timerIsolation: 'afterEach',
     clearTimers: true,
@@ -57,6 +58,7 @@ function normalizeOptions(raw) {
             fakeTimers: report.fakeTimers ?? DEFAULTS.report.fakeTimers,
             promises: normalizePromise(report.promises),
         },
+        verbose: raw.verbose ?? DEFAULTS.verbose,
         delayThreshold: raw.delayThreshold ?? DEFAULTS.delayThreshold,
         timerIsolation: raw.timerIsolation ?? DEFAULTS.timerIsolation,
         clearTimers: raw.clearTimers ?? DEFAULTS.clearTimers,

package/dist/utils/reportLeaks.js

@@ -33,6 +33,19 @@ const reportLeaks = (that, leakRecord) => {
         that.aggregatedReport.fakeTimers += leakRecord.fakeTimers.size;
         that.aggregatedReport.totalDelay += leakRecord.totalDelay;
     }
+    if (that.options.verbose) {
+        const messages = [];
+        const addLeak = (leak) => {
+            messages.push(leak.stack);
+        };
+        leakRecord.promises.forEach(addLeak);
+        leakRecord.timers.forEach(addLeak);
+        leakRecord.fakeTimers.forEach(addLeak);
+        leakRecord.console.forEach(addLeak);
+        if (messages.length) {
+            node_console_1.default.log(messages.join('\n'));
+        }
+    }
     try {
         if (leakRecord.console.length) {
             const message = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jest-doctor",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "jest environment for leak detection",
   "license": "MIT",
   "author": "Stephan Dum",