jest-doctor 0.0.7 → 0.1.1

package/dist/env/jsdom.js

@@ -3,5 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const requireEnvironment_1 = __importDefault(require("../requireEnvironment"));
-exports.default = (0, requireEnvironment_1.default)('jest-environment-jsdom');
+const saveRequire_1 = __importDefault(require("../utils/saveRequire"));
+const createEnvMixin_1 = __importDefault(require("../createEnvMixin"));
+const JSDOMEnvironment = (0, saveRequire_1.default)('jest-environment-jsdom');
+exports.default = (0, createEnvMixin_1.default)(JSDOMEnvironment);

package/dist/env/node.js

@@ -3,5 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const requireEnvironment_1 = __importDefault(require("../requireEnvironment"));
-exports.default = (0, requireEnvironment_1.default)('jest-environment-node');
+const saveRequire_1 = __importDefault(require("../utils/saveRequire"));
+const createEnvMixin_1 = __importDefault(require("../createEnvMixin"));
+const NodeEnvironment = (0, saveRequire_1.default)('jest-environment-node');
+exports.default = (0, createEnvMixin_1.default)(NodeEnvironment);

package/dist/patch/fakeTimers.js

@@ -7,22 +7,16 @@ 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;
-    const originalFakeTimerInstall = fakeTimers?.install;
-    if (fakeTimers && originalFakeTimerInstall) {
-        const originalClearAllTimers = modernFakeTimers.clearAllTimers.bind(modernFakeTimers);
-        modernFakeTimers.clearAllTimers = () => {
-            that.leakRecords.get(that.currentTestName)?.fakeTimers.clear();
-            originalClearAllTimers();
-        };
-        fakeTimers.install = (config) => {
-            const clock = originalFakeTimerInstall(config);
-            const originalFakeSetTimeout = clock.setTimeout.bind(clock);
-            const originalFakeSetInterval = clock.setInterval.bind(clock);
-            const originalFakeClearTimeout = clock.clearTimeout.bind(clock);
-            const originalFakeClearInterval = clock.clearInterval.bind(clock);
-            clock.setTimeout = function (callback, delay) {
+    const env = that.global;
+    const patchTimersLifeCycles = (api) => {
+        const originalUseFakeTimers = api.useFakeTimers.bind(api);
+        api.useFakeTimers = (config) => {
+            originalUseFakeTimers(config);
+            const originalFakeSetTimeout = env.setTimeout.bind(env);
+            const originalFakeSetInterval = env.setInterval.bind(env);
+            const originalFakeClearTimeout = env.clearTimeout.bind(env);
+            const originalFakeClearInterval = env.clearInterval.bind(env);
+            env.setTimeout = Object.assign(function (callback, delay) {
                 const fakeTimeout = that.leakRecords.get(that.currentTestName)?.fakeTimers;
                 const timerId = originalFakeSetTimeout(() => {
                     fakeTimeout?.delete(timerId);
@@ -37,8 +31,8 @@ const patchFakeTimers = (that) => {
                     });
                 }
                 return timerId;
-            };
-            clock.setInterval = function (callback, delay) {
+            }, env.setTimeout);
+            env.setInterval = Object.assign(function (callback, delay) {
                 const intervalId = originalFakeSetInterval(callback, delay);
                 const stack = (0, getStack_1.default)(that.global.setInterval);
                 if (!(0, isIgnored_1.default)(stack, that.options.report.fakeTimers.ignore)) {
@@ -51,22 +45,35 @@ const patchFakeTimers = (that) => {
                     });
                 }
                 return intervalId;
-            };
-            clock.clearTimeout = (timerId) => {
+            }, env.setInterval);
+            env.clearTimeout = Object.assign((timerId) => {
                 that.leakRecords.get(that.currentTestName)?.fakeTimers.delete(timerId);
                 originalFakeClearTimeout(timerId);
-            };
-            clock.clearInterval = (intervalId) => {
+            }, env.clearTimeout);
+            env.clearInterval = Object.assign((intervalId) => {
                 that.leakRecords
                     .get(that.currentTestName)
                     ?.fakeTimers.delete(intervalId);
                 originalFakeClearInterval(intervalId);
-            };
-            return clock;
+            }, env.clearInterval);
         };
+        const originalClearAllTimers = api.clearAllTimers.bind(api);
+        api.clearAllTimers = () => {
+            that.leakRecords.get(that.currentTestName)?.fakeTimers.clear();
+            originalClearAllTimers();
+        };
+    };
+    if (that.fakeTimersModern) {
+        patchTimersLifeCycles(that.fakeTimersModern);
+    }
+    else {
+        that.original.stderr(chalk_1.default.yellow('\nModern fake timers could not be mocked!'));
+    }
+    if (that.fakeTimers) {
+        patchTimersLifeCycles(that.fakeTimers);
     }
     else {
-        that.original.stderr(chalk_1.default.yellow('\nFake timers could not be mocked!'));
+        that.original.stderr(chalk_1.default.yellow('\nLegacy fake timers could not be mocked!'));
     }
 };
 exports.default = patchFakeTimers;

package/dist/patch/timers.d.ts

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

package/dist/patch/timers.js

@@ -6,61 +6,72 @@ 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 patchTimers = (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 && isAllowed) {
-                if (owner !== consts_1.MAIN_THREAD && delay) {
+    const patch = () => {
+        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 && isAllowed) {
+                    if (owner !== consts_1.MAIN_THREAD && delay) {
+                        leakRecord.totalDelay += delay;
+                    }
+                    leakRecord.timers.delete(timerId);
+                }
+                callback();
+            }, delay);
+            leakRecord?.timers.set(timerId, {
+                type: 'timeout',
+                delay: delay || 0,
+                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 (isAllowed && owner !== consts_1.MAIN_THREAD && delay && leakRecord) {
                     leakRecord.totalDelay += delay;
                 }
-                leakRecord.timers.delete(timerId);
-            }
-            callback();
-        }, delay);
-        leakRecord?.timers.set(timerId, {
-            type: 'timeout',
-            delay: delay || 0,
-            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 (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,
-            isAllowed,
-            stack,
-        });
-        return intervalId;
-    }, that.original.setInterval);
-    env.clearTimeout = (timerId) => {
-        that.leakRecords
-            .get(that.currentTestName)
-            ?.timers.delete(timerId);
-        that.original.clearTimeout(timerId);
-    };
-    env.clearInterval = (intervalId) => {
-        that.leakRecords
-            .get(that.currentTestName)
-            ?.timers.delete(intervalId);
-        that.original.clearInterval(intervalId);
+                callback();
+            }, delay);
+            that.leakRecords.get(owner)?.timers.set(intervalId, {
+                type: 'interval',
+                delay: delay || 0,
+                isAllowed,
+                stack,
+            });
+            return intervalId;
+        }, that.original.setInterval);
+        env.clearTimeout = (timerId) => {
+            that.leakRecords
+                .get(that.currentTestName)
+                ?.timers.delete(timerId);
+            that.original.clearTimeout(timerId);
+        };
+        env.clearInterval = (intervalId) => {
+            that.leakRecords
+                .get(that.currentTestName)
+                ?.timers.delete(intervalId);
+            that.original.clearInterval(intervalId);
+        };
     };
+    if (that.fakeTimers) {
+        // legacy fake timers will overwrite the existing objects and not restore them
+        const originalUseRealTimers = that.fakeTimers.useRealTimers.bind(that.fakeTimers);
+        that.fakeTimers.useRealTimers = () => {
+            originalUseRealTimers();
+            patch();
+        };
+    }
+    patch();
 };
-exports.default = timers;
+exports.default = patchTimers;

package/dist/types.d.ts

@@ -1,4 +1,3 @@
-import type { ModernFakeTimers } from '@jest/fake-timers';
 import { JestEnvironment } from '@jest/environment';
 import initOriginal from './utils/initOriginal';
 import type { AsyncHook } from 'node:async_hooks';
@@ -40,20 +39,12 @@ export interface LeakRecord {
     totalDelay: number;
     fakeTimers: Map<number, TimerRecord>;
 }
-interface Clock {
+export interface Clock {
     setTimeout: (callback: () => void, delay?: number) => number;
     setInterval: (callback: () => void, delay?: number) => number;
     clearTimeout: (timeoutId: number) => void;
     clearInterval: (intervalId: number) => void;
 }
-export interface FakeTimers extends Omit<ModernFakeTimers, '_fakeTimers'> {
-    _fakeTimers: {
-        install: (config: unknown) => Clock;
-    };
-    _clock: {
-        timers: Record<string, unknown>;
-    };
-}
 export type TimerIsolation = 'afterEach' | 'immediate';
 export type OnError = false | 'throw' | 'warn';
 export type ThrowOrWarn = 'throw' | 'warn';
@@ -110,9 +101,8 @@ export interface AggregatedReport {
     processOutputs: number;
     totalDelay: number;
 }
-export interface JestDoctorEnvironment {
+export interface JestDoctorEnvironment extends JestEnvironment {
     global: JestEnvironment['global'];
-    fakeTimersModern: ModernFakeTimers | null;
     original: ReturnType<typeof initOriginal>;
     currentTestName: string;
     leakRecords: Map<string, LeakRecord>;

package/dist/utils/cleanupAfterTest.js

@@ -3,11 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const cleanupAfterTest = (that, leakRecord, testName) => {
     if (that.currentAfterEachCount === 0) {
         if (that.options.clearTimers) {
-            // to avoid warnings when useRealTimers is enabled, but there are still pending fake timers,
-            // the internal object will be reset instead of calling that.fakeTimersModern.clearAllTimers
-            const fakeTimers = that.fakeTimersModern?._clock?.timers || {};
-            for (const key of Object.keys(fakeTimers)) {
-                delete fakeTimers[key];
+            // @ts-expect-error it is public but signaled as internal
+            if (that.fakeTimers?._fakingTime) {
+                that.fakeTimers.clearAllTimers();
+            }
+            // @ts-expect-error it is public but signaled as internal
+            if (that.fakeTimersModern?._fakingTime) {
+                that.fakeTimersModern.clearAllTimers();
             }
             for (const [timerId, record] of leakRecord.timers.entries()) {
                 if (record.type === 'timeout') {

package/dist/utils/getStack.js

@@ -6,15 +6,18 @@ const getStack = (stackFrom) => {
     };
     Error.captureStackTrace(error, stackFrom);
     const lines = error.stack.replace(/\\/g, '/').split('\n');
+    lines.shift();
     const finalStack = [];
     for (const line of lines) {
-        if (!line.includes('(node:internal/') &&
+        if (/[/\\]/.test(line) && // this will remove all anonymous frames without a path
+            !line.includes('(node:internal/') &&
             !line.includes('node_modules/jest-runtime') &&
             !line.includes('node_modules/jest-circus') &&
-            !line.includes('node_modules/jest-runner')) {
+            !line.includes('node_modules/jest-runner') &&
+            !line.includes('node_modules/jest-doctor')) {
             finalStack.push(line);
         }
     }
-    return '\n' + finalStack.join('\n');
+    return finalStack.join('\n');
 };
 exports.default = getStack;

package/dist/utils/reportLeaks.js

@@ -47,16 +47,28 @@ const reportLeaks = (that, leakRecord) => {
         that.aggregatedReport.totalDelay += leakRecord.totalDelay;
     }
     if (that.options.verbose) {
-        const logLeak = (leak) => {
-            that.original.stderr('\n' + chalk_1.default.red(leak.stack) + '\n');
+        const logLeak = (label, message, property) => {
+            if (message && report[property] && report[property].onError !== 'warn') {
+                that.original.stderr('\n' + chalk_1.default.red(label) + '\n' + chalk_1.default.red(message) + '\n');
+            }
         };
-        leakRecord.promises.forEach(logLeak);
+        leakRecord.promises.forEach(({ stack }) => {
+            logLeak(`Open promise:`, stack, 'promises');
+        });
         if (that.currentAfterEachCount === 0) {
-            accountAbleTimers.forEach(logLeak);
-            leakRecord.fakeTimers.forEach(logLeak);
+            accountAbleTimers.forEach(({ stack }) => {
+                logLeak(`Open timer:`, stack, 'timers');
+            });
+            leakRecord.fakeTimers.forEach(({ stack }) => {
+                logLeak(`Open fake timer:`, stack, 'fakeTimers');
+            });
         }
-        leakRecord.console.forEach(logLeak);
-        leakRecord.processOutputs.forEach(logLeak);
+        leakRecord.console.forEach(({ stack }) => {
+            logLeak(`Console output:`, stack, 'console');
+        });
+        leakRecord.processOutputs.forEach(({ stack }) => {
+            logLeak(`Process output:`, stack, 'processOutputs');
+        });
     }
     try {
         checkErrorArray(leakRecord.console, 'console output(s)', report.console.onError);

package/dist/utils/saveRequire.d.ts

@@ -0,0 +1,3 @@
+import { type JestDoctorConstructor } from '../createEnvMixin';
+declare const saveRequire: (envName: string) => JestDoctorConstructor;
+export default saveRequire;

package/dist/utils/saveRequire.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const saveRequire = (envName) => {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        return require(envName).default;
+    }
+    catch (error) {
+        throw new Error(`${envName} needs to be installed as a peer dependency`, {
+            cause: error,
+        });
+    }
+};
+exports.default = saveRequire;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jest-doctor",
-  "version": "0.0.7",
-  "description": "jest environment for leak detection",
+  "version": "0.1.1",
+  "description": "jest environment for leak and issue detection",
   "license": "MIT",
   "author": "Stephan Dum",
   "type": "commonjs",
@@ -13,7 +13,6 @@
   "exports": {
     "./package.json": "./package.json",
     "./createEnvMixin": "./dist/createEnvMixin.js",
-    "./require": "./dist/requireEnvironment.js",
     "./env/node": "./dist/env/node.js",
     "./env/jsdom": "./dist/env/jsdom.js",
     "./reporter": "./dist/reporter.js"
@@ -22,6 +21,16 @@
     "dist",
     "readme.md"
   ],
+  "keywords": [
+    "jest",
+    "jest-doctor",
+    "leak detection",
+    "open handles",
+    "issue detection",
+    "testing",
+    "jest environment",
+    "test hygien"
+  ],
   "types": "./dist/types.d.ts",
   "devDependencies": {
     "@dev/eslint": "1.0.0",

package/readme.md

@@ -100,7 +100,6 @@ export default {
 
 ## Limitations
 - it.concurrent is replaced with a sync version
-- legacy fake timers are not mocked
 - test and hook blocks do not support done callback or generators
 - promises that resolve within the next tick cannot be tracked, for example:
 ```js
@@ -108,11 +107,24 @@ Promise.resolve().then(() => {
   /* i am not tracked as unresolved */
 });
 ```
-- Promise.race, Promise.any and Promise.all can only accept unchained promises, or they will report the chained promise as open.
+- Promise.race, Promise.any and Promise.all do not support nested blocks.
 ```js
-const p1 = Promise.resolve().then(() => { /* not allowed */});
-const p2 = Promise.resolve();
-await Promise.race([p1, p2]);
+const doSomething = async () => {
+  // both promises will be tracked and never released
+  await someAsyncTask();
+  return new Promise(() => { setTimeout(resolve, 10)})
+};
+
+const p1 = Promise.resolve()
+  .then(() => { /* no problem if not async */});
+
+const p2 = Promise.resolve()
+  .then(() => new Promise((resolve) => {
+    /* the promise will be also always tracked */
+    resolve();
+  }));
+
+await Promise.race([p1, p2, doSomething()]);
 ```
 
 -  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/requireEnvironment.d.ts

@@ -1,61 +0,0 @@
-import { type JestDoctorConstructor } from './createEnvMixin';
-declare const requireEnvironment: (envName: string) => {
-    new (config: import("@jest/environment").JestEnvironmentConfig, context: import("@jest/environment").EnvironmentContext): {
-        currentTestName: string;
-        readonly leakRecords: Map<string, import("./types").LeakRecord>;
-        readonly original: {
-            setTimeout: typeof setTimeout;
-            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;
-                warn: (message?: any, ...optionalParams: any[]) => void;
-                error: (message?: any, ...optionalParams: any[]) => void;
-                debug: (message?: any, ...optionalParams: any[]) => void;
-                trace: (message?: any, ...optionalParams: any[]) => void;
-            };
-        };
-        readonly promiseOwner: Map<number, string>;
-        readonly asyncHookDetector?: import("async_hooks").AsyncHook;
-        readonly asyncHookCleaner?: import("async_hooks").AsyncHook;
-        readonly options: import("./types").NormalizedOptions;
-        seenTearDown: boolean;
-        currentAfterEachCount: number;
-        readonly reporterTmpDir: string;
-        readonly testPath: string;
-        readonly aggregatedReport: {
-            testPath: string;
-            promises: number;
-            timers: number;
-            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"];
-        teardown(): Promise<void>;
-        global: import("@jest/environment").JestEnvironment["global"];
-        fakeTimers: import("@jest/fake-timers").LegacyFakeTimers<unknown> | null;
-        fakeTimersModern: import("@jest/fake-timers").ModernFakeTimers | null;
-        moduleMocker: import("jest-mock").ModuleMocker | null;
-        getVmContext: () => import("vm").Context | null;
-        exportConditions: (() => Array<string>) | undefined;
-    };
-} & JestDoctorConstructor;
-export default requireEnvironment;

package/dist/requireEnvironment.js

@@ -1,20 +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 createEnvMixin_1 = __importDefault(require("./createEnvMixin"));
-const requireEnvironment = (envName) => {
-    try {
-        const JsdomEnvironment = 
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        require(envName).default;
-        return (0, createEnvMixin_1.default)(JsdomEnvironment);
-    }
-    catch (error) {
-        throw new Error(`${envName} needs to be installed as a peer dependency`, {
-            cause: error,
-        });
-    }
-};
-exports.default = requireEnvironment;