Add mocks to NodeJS "timers" module

src/fake-timers-src.js

@@ -1,6 +1,14 @@
 "use strict";
 
 const globalObject = require("@sinonjs/commons").global;
+let timersModule;
+if (typeof require === "function" && typeof module === "object") {
+    try {
+        timersModule = require("timers");
+    } catch (e) {
+        // ignored
+    }
+}
 
 /**
  * @typedef {object} IdleDeadline
@@ -39,13 +47,13 @@
 
 /**
  * @typedef RequestAnimationFrame
  * @property {function(number):void} requestAnimationFrame
  * @returns {number} - the id
  */
 
 /**
  * @typedef Performance
  * @property {function(): number} now
  */
 
 /* eslint-disable jsdoc/require-property-description */
@@ -317,7 +325,7 @@
         return timer && timer.callAt >= from && timer.callAt <= to;
     }
 
     /**
      * @param {Clock} clock
      * @param {Timer} job
      */
@@ -619,7 +627,7 @@
     }
 
     /* eslint consistent-return: "off" */
     /**
      * Timer comparitor
      *
      * @param {Timer} a
@@ -751,7 +759,7 @@
         }
     }
 
     /**
      * Gets clear handler name for a given timer type
      *
      * @param {string} ttype
@@ -763,7 +771,7 @@
         return `clear${ttype}`;
     }
 
     /**
      * Gets schedule handler name for a given timer type
      *
      * @param {string} ttype
@@ -775,7 +783,7 @@
         return `set${ttype}`;
     }
 
     /**
      * Creates an anonymous function to warn only once
      */
     function createWarnOnce() {
@@ -787,7 +795,7 @@
     }
     const warnOnce = createWarnOnce();
 
     /**
      * @param {Clock} clock
      * @param {number} timerId
      * @param {string} ttype
@@ -886,6 +894,14 @@
                     }
                 }
             }
+            if (clock.timersModuleMocks) {
+                for (const [
+                    methodName,
+                    originalMethod,
+                ] of clock.timersModuleMocks) {
+                    timersModule[methodName] = originalMethod;
+                }
+            }
         }
 
         if (config.shouldAdvanceTime === true) {
@@ -968,8 +984,8 @@
 
     /**
      * @typedef {object} Timers
      * @property {setTimeout} setTimeout
      * @property {clearTimeout} clearTimeout
      * @property {setInterval} setInterval
      * @property {clearInterval} clearInterval
      * @property {Date} Date
@@ -1733,7 +1749,9 @@
                 );
             }
         }
-
+        if (_global === globalObject && timersModule) {
+            clock.timersModuleMocks = [];
+        }
         for (i = 0, l = clock.methods.length; i < l; i++) {
             const nameOfMethodToReplace = clock.methods[i];
             if (nameOfMethodToReplace === "hrtime") {
@@ -1753,6 +1771,15 @@
             } else {
                 hijackMethod(_global, nameOfMethodToReplace, clock);
             }
+            if (
+                clock.timersModuleMocks !== undefined &&
+                timersModule[nameOfMethodToReplace]
+            ) {
+                const original = timersModule[nameOfMethodToReplace];
+                clock.timersModuleMocks.push([nameOfMethodToReplace, original]);
+                timersModule[nameOfMethodToReplace] =
+                    _global[nameOfMethodToReplace];
+            }
         }
 
         return clock;

test/issue-466-test.js

@@ -0,0 +1,144 @@
+"use strict";
+
+const { FakeTimers, assert, refute } = require("./helpers/setup-tests");
+const { sinon } = require("@sinonjs/referee-sinon");
+var timersModule;
+
+if (typeof require === "function" && typeof module === "object") {
+    try {
+        timersModule = require("timers");
+    } catch (e) {
+        // ignored
+    }
+}
+if (!timersModule) {
+    // eslint-disable-next-line no-console
+    console.warn("timers module is not supported in the current environment.");
+    return;
+}
+
+/**
+ * Returns elements that are present in both lists.
+ *
+ * @function
+ * @template E
+ * @param {E[]} [list1]
+ * @param {E[]} [list2]
+ * @return {E[]}
+ */
+function getIntersection(list1, list2) {
+    return list1.filter((value) => list2.indexOf(value) !== -1);
+}
+
+/**
+ * Get property names and original values from timers module.
+ *
+ * @function
+ * @param {string[]} [toFake]
+ * @return {{propertyName: string, originalValue: any}[]}
+ */
+function getOriginals(toFake) {
+    return toFake.map((propertyName) => ({
+        propertyName,
+        originalValue: timersModule[propertyName],
+    }));
+}
+
+describe("issue #466", function () {
+    afterEach(function () {
+        if (this.clock) {
+            this.clock.uninstall();
+            delete this.clock;
+        }
+    });
+
+    it("should install all timers on timers module", function () {
+        const toFake = getIntersection(
+            Object.getOwnPropertyNames(timersModule),
+            Object.getOwnPropertyNames(FakeTimers.timers)
+        );
+        const originals = getOriginals(toFake);
+
+        this.clock = FakeTimers.install();
+
+        for (const { propertyName, originalValue } of originals) {
+            refute.same(timersModule[propertyName], originalValue);
+        }
+    });
+
+    it("should uninstall all timers on timers module", function () {
+        const toFake = getIntersection(
+            Object.getOwnPropertyNames(timersModule),
+            Object.getOwnPropertyNames(FakeTimers.timers)
+        );
+        const originals = getOriginals(toFake);
+
+        this.clock = FakeTimers.install();
+        this.clock.uninstall();
+
+        for (const { propertyName, originalValue } of originals) {
+            assert.same(timersModule[propertyName], originalValue);
+        }
+    });
+
+    it("should have synchronized clocks on global and timers module", function () {
+        this.clock = FakeTimers.install();
+
+        const globalStub = sinon.stub();
+        const timersStub = sinon.stub();
+
+        timersModule.setTimeout(timersStub, 5);
+        setTimeout(globalStub, 5);
+        this.clock.tick(5);
+        assert(globalStub.calledOnce);
+        assert(timersStub.calledOnce);
+    });
+
+    it("fakes and resets provided methods on timers module", function () {
+        const toFake = ["setTimeout", "Date"];
+        const originals = getOriginals(toFake);
+        this.clock = FakeTimers.install({ toFake });
+
+        for (const { propertyName, originalValue } of originals) {
+            if (originalValue === undefined) {
+                assert.same(timersModule[propertyName], originalValue);
+            } else {
+                refute.same(timersModule[propertyName], originalValue);
+            }
+        }
+    });
+
+    it("resets faked methods on timers module", function () {
+        const toFake = ["setTimeout", "Date"];
+        const originals = getOriginals(toFake);
+
+        this.clock = FakeTimers.install({ toFake });
+        this.clock.uninstall();
+
+        for (const { propertyName, originalValue } of originals) {
+            assert.same(timersModule[propertyName], originalValue);
+        }
+    });
+
+    it("does not fake methods not provided on timers module", function () {
+        const toFake = ["setTimeout", "Date"];
+        const notToFake = ["clearTimeout", "setInterval", "clearInterval"];
+        const originals = getOriginals(notToFake);
+
+        this.clock = FakeTimers.install({ toFake });
+
+        for (const { propertyName, originalValue } of originals) {
+            assert.same(timersModule[propertyName], originalValue);
+        }
+    });
+
+    it("does not fake timers module on custom global object", function () {
+        const original = timersModule.setTimeout;
+        this.clock = FakeTimers.withGlobal({
+            Date: Date,
+            setTimeout: sinon.fake(),
+            clearTimeout: sinon.fake(),
+        }).install();
+        assert.same(timersModule.setTimeout, original);
+    });
+});