jest-doctor 0.0.4 → 0.0.5

package/dist/createEnvMixin.js

@@ -21,7 +21,6 @@ const hook_1 = __importDefault(require("./patch/hook"));
 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
@@ -57,8 +56,7 @@ const createEnvMixin = (Environment) => {
                 : '';
             this.options = (0, normalizeOptions_1.default)(config.projectConfig.testEnvironmentOptions);
             (0, initLeakRecord_1.default)(this, consts_1.MAIN_THREAD);
-            if (this.options.report.promises &&
-                this.options.report.promises.patch === 'async_hooks') {
+            if (this.options.report.promises) {
                 this.asyncHookCleaner = (0, createAsyncHookCleaner_1.default)(this);
                 this.asyncHookDetector = (0, createAsyncHookDetector_1.default)(this);
             }
@@ -76,9 +74,6 @@ const createEnvMixin = (Environment) => {
             }
             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,
@@ -104,6 +99,14 @@ const createEnvMixin = (Environment) => {
                 (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,
+                });
             }
             await super.handleEvent?.(circusEvent, circusState);
         }

package/dist/patch/promiseConcurrency.js

@@ -4,20 +4,26 @@ 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 = () => {
+        return fn(concurrentPromises).finally(() => {
             if (promises) {
-                concurrentPromises.forEach((racePromise) => {
-                    promises.delete(racePromise);
+                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);
+                            }
+                        });
+                    }
                 });
             }
-        };
-        return fn(concurrentPromises).then((returnValues) => {
-            removePromises();
-            return returnValues;
-        }, (error) => {
-            removePromises();
-            throw error;
         });
     };
     env.Promise.race = concurrencyFactor(env.Promise.race.bind(env.Promise));

package/dist/types.d.ts

@@ -1,6 +1,7 @@
 import type { ModernFakeTimers } from '@jest/fake-timers';
 import { JestEnvironment } from '@jest/environment';
 import initOriginal from './utils/initOriginal';
+import type { AsyncHook } from 'node:async_hooks';
 export interface TimerRecord {
     type: 'timeout' | 'interval' | 'fakeTimeout' | 'fakeInterval';
     delay: number;
@@ -10,6 +11,8 @@ export interface TimerRecord {
 export interface PromiseRecord {
     stack: string;
     testName: string;
+    asyncId: number;
+    parentAsyncId: number;
 }
 export interface ConsoleRecord {
     method: keyof Console;
@@ -39,9 +42,8 @@ export interface FakeTimers extends Omit<ModernFakeTimers, '_fakeTimers'> {
     };
 }
 export type TimerIsolation = 'afterEach' | 'immediate';
-export type OnError = boolean | 'throw' | 'warn';
+export type OnError = false | 'throw' | 'warn';
 export type ThrowOrWarn = 'throw' | 'warn';
-export type Patch = 'async_hooks' | 'promise';
 export interface ConsoleOptions {
     onError: ThrowOrWarn;
     methods: Array<keyof Console>;
@@ -53,10 +55,7 @@ export interface NormalizedOptions {
         console: NormalizedConsoleOptions;
         timers: OnError;
         fakeTimers: OnError;
-        promises: false | {
-            onError: ThrowOrWarn;
-            patch: Patch;
-        };
+        promises: OnError;
     };
     verbose: boolean;
     delayThreshold: number;
@@ -68,16 +67,12 @@ export type RawConsoleOptions = boolean | {
     methods?: Array<keyof Console>;
     ignore?: string | RegExp | Array<string | RegExp>;
 };
-export type RawPromise = boolean | {
-    onError?: ThrowOrWarn;
-    patch?: Patch;
-};
 export interface RawOptions {
     report?: {
         console?: RawConsoleOptions;
         timers?: OnError;
         fakeTimers?: OnError;
-        promises?: RawPromise;
+        promises?: OnError;
     };
     verbose?: boolean;
     delayThreshold?: number;
@@ -103,5 +98,6 @@ export interface JestDoctorEnvironment {
     options: NormalizedOptions;
     aggregatedReport: AggregatedReport;
     asyncIdToPromise: Map<number, Promise<unknown>>;
+    asyncHookDetector?: AsyncHook;
 }
 export {};

package/dist/utils/createAsyncHookCleaner.js

@@ -5,8 +5,9 @@ const createAsyncHookCleaner = (that) => {
     return (0, node_async_hooks_1.createHook)({
         promiseResolve(asyncId) {
             const owner = that.promiseOwner.get(asyncId);
-            if (!owner)
+            if (!owner) {
                 return;
+            }
             const promise = that.asyncIdToPromise.get(asyncId);
             if (promise) {
                 that.leakRecords.get(owner)?.promises.delete(promise);

package/dist/utils/createAsyncHookDetector.js

@@ -6,9 +6,10 @@ 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, _, resource) => {
-        if (type !== 'PROMISE')
+    const init = (asyncId, type, parentAsyncId, resource) => {
+        if (type !== 'PROMISE') {
             return;
+        }
         const promise = resource;
         const owner = that.currentTestName;
         that.promiseOwner.set(asyncId, owner);
@@ -16,6 +17,8 @@ const createAsyncHookDetector = (that) => {
         that.leakRecords.get(owner)?.promises.set(promise, {
             stack: (0, getStack_1.default)(init, 'Promise'),
             testName: owner,
+            asyncId,
+            parentAsyncId,
         });
     };
     return (0, node_async_hooks_1.createHook)({ init });

package/dist/utils/getStack.js

@@ -5,6 +5,6 @@ const getStack = (stackFrom, prefix) => {
         stack: '',
     };
     Error.captureStackTrace(error, stackFrom);
-    return prefix + ' ' + error.stack;
+    return prefix + ' ' + error.stack.replace(/\\/g, '/');
 };
 exports.default = getStack;

package/dist/utils/normalizeOptions.d.ts

@@ -1,3 +1,3 @@
 import { NormalizedOptions, RawOptions } from '../types';
-export declare function normalizeOptions(raw: RawOptions): NormalizedOptions;
+export declare function normalizeOptions(raw?: RawOptions): NormalizedOptions;
 export default normalizeOptions;

package/dist/utils/normalizeOptions.js

@@ -1,6 +1,40 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeOptions = normalizeOptions;
+const zod = __importStar(require("zod"));
 const DEFAULTS = {
     report: {
         console: {
@@ -10,58 +44,56 @@ const DEFAULTS = {
         },
         timers: 'throw',
         fakeTimers: 'throw',
-        promises: {
-            onError: 'throw',
-            patch: 'async_hooks',
-        },
+        promises: 'throw',
     },
     verbose: false,
     delayThreshold: 0,
     timerIsolation: 'afterEach',
     clearTimers: true,
 };
-const normalizeConsole = (rawConsole) => {
-    if (rawConsole === undefined || rawConsole === true) {
-        return DEFAULTS.report.console;
-    }
-    if (typeof rawConsole === 'object') {
-        return {
-            onError: rawConsole.onError ?? DEFAULTS.report.console.onError,
-            methods: rawConsole.methods ?? DEFAULTS.report.console.methods,
-            ignore: Array.isArray(rawConsole.ignore)
-                ? rawConsole.ignore
-                : rawConsole.ignore === undefined
-                    ? []
-                    : [rawConsole.ignore],
-        };
-    }
-    return false;
-};
-const normalizePromise = (rawPromise) => {
-    if (rawPromise === undefined || rawPromise === true) {
-        return DEFAULTS.report.promises;
+const onError = zod
+    .union([zod.literal(false), zod.enum(['throw', 'warn'])])
+    .default('throw');
+const schema = zod
+    .object({
+    report: zod
+        .object({
+        console: zod
+            .union([
+            zod.literal(false),
+            zod.object({
+                onError: zod.enum(['throw', 'warn']).default('throw'),
+                methods: zod
+                    .array(zod.enum(['log', 'warn', 'error', 'info', 'debug']))
+                    .default(DEFAULTS.report.console.methods),
+                ignore: zod
+                    .union([
+                    zod.string(),
+                    zod.instanceof(RegExp),
+                    zod.array(zod.union([zod.string(), zod.instanceof(RegExp)])),
+                ])
+                    .transform((value) => (Array.isArray(value) ? value : [value]))
+                    .default([]),
+            }),
+        ])
+            .default(DEFAULTS.report.console),
+        timers: onError,
+        fakeTimers: onError,
+        promises: onError,
+    })
+        .default(DEFAULTS.report),
+    verbose: zod.boolean().default(false),
+    delayThreshold: zod.int().gte(0).default(0),
+    timerIsolation: zod.enum(['afterEach', 'immediate']).default('afterEach'),
+    clearTimers: zod.boolean().default(true),
+})
+    .default(DEFAULTS);
+function normalizeOptions(raw) {
+    try {
+        return schema.parse(raw || {});
     }
-    if (typeof rawPromise === 'object') {
-        return {
-            onError: rawPromise.onError ?? DEFAULTS.report.promises.onError,
-            patch: rawPromise.patch ?? DEFAULTS.report.promises.patch,
-        };
+    catch (error) {
+        throw zod.prettifyError(error);
     }
-    return false;
-};
-function normalizeOptions(raw) {
-    const report = raw.report ?? {};
-    return {
-        report: {
-            console: normalizeConsole(report.console),
-            timers: report.timers ?? DEFAULTS.report.timers,
-            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,
-    };
 }
 exports.default = normalizeOptions;

package/dist/utils/reportLeaks.js

@@ -13,8 +13,7 @@ const reportLeaks = (that, leakRecord) => {
                 leakRecord[property].values().next().value?.stack,
             ].join('\n');
             const option = that.options.report[property];
-            if (option === 'throw' ||
-                (typeof option === 'object' && option.onError === 'throw')) {
+            if (option === 'throw') {
                 const error = new Error();
                 error.stack = message;
                 throw error;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jest-doctor",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "jest environment for leak detection",
   "license": "MIT",
   "author": "Stephan Dum",
@@ -38,11 +38,11 @@
     "@types/react": "^19.2.8",
     "@types/react-dom": "^19.2.3",
     "c8": "^10.1.3",
-    "cross-env": "^10.1.0",
     "cross-spawn": "^7.0.6",
     "eslint": "^9.39.2",
-    "istanbul-lib-report": "^3.0.1",
     "jest": "30.2.0",
+    "jest-environment-jsdom": "^30.2.0",
+    "jest-environment-node": "^30.2.0",
     "memfs": "^4.52.0",
     "nyc": "^17.1.0",
     "react": "^19.2.3",
@@ -63,7 +63,8 @@
     }
   },
   "dependencies": {
-    "chalk": "4.1.2"
+    "chalk": "4.1.2",
+    "zod": "^4.3.5"
   },
   "scripts": {
     "typecheck": "tsc",

package/readme.md

@@ -40,12 +40,8 @@ The environment can be configured through jest config `testEnvironmentOptions`:
 - **report**: an object defining which leaks should be tracked and reported
   - **timers**: `false | 'warn' | 'trow'` (default `throw`) whether normal setTimeout and setInterval should be reported and how
   - **fakeTimers**: `false | 'warn' | 'trow'` (default `throw`) same as timers but for fake api
-  - **promises**: `false` or object
-      - **onError**: `'warn' | 'trow'` (default `throw`) indicating if promises should be reported and how
-      - **patch**: `'async_hooks' | 'promise'` (default `async_hooks`) controls how to patch promises
-          - **async_hooks**: uses node async_hook API to detect any promise generation, robust solution but with an overhead.
-          - **promise**: overwrites the global Promise object which is faster but will not detect: internal promises, async await, native API promises!
-  -  **console**: `false` or object (default object)
+  - **promises**: `false | 'warn' | 'trow'` (default `throw`) indicating if promises should be reported and how
+  - **console**: `false` or object (default object)
       - **onError**: `'warn' | 'trow'` (default `throw`) how to handle reporting
       - **methods**: `keyof Console` (default all methods) which console methods should be tracked
       - **ignore**: `string | regexp | Array<string | regexp>` (default: []) allows to excluded console output from tracking
@@ -67,9 +63,7 @@ export default {
       },
       timers: 'warn',
       fakeTimers: 'warn',
-      promises: {
-        onErro: 'warn',
-      },
+      promises:  'warn',
     },
     delayThreshold: 1000,
     timerIsolation: 'afterEach',
@@ -100,9 +94,11 @@ Promise.resolve().then(() => {
   /* i am not tracked as unresolved */
 });
 ```
-- injectGlobals must be used for totalDelay and test attribution to work, because imports from jest can not be patched! Also this could give a wrong sense of confidence because one test could have open timers or promises that resolve while running other tests and are not present in the final report.
+- Promise.race and Promise.any can only accept unchained promises, or they will report the chained promise as open.
 ```js
-import { expect, it, describe, beforeEach /*...*/ } from '@jest/globals';
+const p1 = Promise.resolve().then(() => { /* not allowed */});
+const p2 = Promise.resolve();
+await Promise.race([p1, p2]);
 ```
 
 - console, setTimeout / setInterval can also be imported and will not participate in leak detection in these cases, but this can also serve as exit hatch if needed.

package/dist/patch/promise.d.ts

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

package/dist/patch/promise.js

@@ -1,34 +0,0 @@
-"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 patchPromise = (that) => {
-    const OriginalPromise = that.global.Promise;
-    class TrackedPromise extends OriginalPromise {
-        constructor(executor) {
-            let resolveRef;
-            let rejectRef;
-            super((resolve, reject) => {
-                resolveRef = resolve;
-                rejectRef = reject;
-            });
-            const promiseLeaks = that.leakRecords.get(that.currentTestName)?.promises;
-            promiseLeaks?.set(this, {
-                testName: that.currentTestName,
-                stack: (0, getStack_1.default)(that.global.Promise, 'Promise'),
-            });
-            executor((value) => {
-                promiseLeaks?.delete(this);
-                resolveRef(value);
-            }, (reason) => {
-                promiseLeaks?.delete(this);
-                rejectRef(reason);
-            });
-        }
-    }
-    Object.assign(Promise, OriginalPromise);
-    that.global.Promise = TrackedPromise;
-};
-exports.default = patchPromise;

package/dist/patch/race.d.ts

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

package/dist/patch/race.js

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