674 lines
16 KiB
JavaScript
674 lines
16 KiB
JavaScript
'use strict';
|
|
|
|
Object.defineProperty(exports, '__esModule', {
|
|
value: true
|
|
});
|
|
exports.default = void 0;
|
|
|
|
function _util() {
|
|
const data = _interopRequireDefault(require('util'));
|
|
|
|
_util = function () {
|
|
return data;
|
|
};
|
|
|
|
return data;
|
|
}
|
|
|
|
function _jestMessageUtil() {
|
|
const data = require('jest-message-util');
|
|
|
|
_jestMessageUtil = function () {
|
|
return data;
|
|
};
|
|
|
|
return data;
|
|
}
|
|
|
|
function _jestUtil() {
|
|
const data = require('jest-util');
|
|
|
|
_jestUtil = function () {
|
|
return data;
|
|
};
|
|
|
|
return data;
|
|
}
|
|
|
|
function _interopRequireDefault(obj) {
|
|
return obj && obj.__esModule ? obj : {default: obj};
|
|
}
|
|
|
|
function _defineProperty(obj, key, value) {
|
|
if (key in obj) {
|
|
Object.defineProperty(obj, key, {
|
|
value: value,
|
|
enumerable: true,
|
|
configurable: true,
|
|
writable: true
|
|
});
|
|
} else {
|
|
obj[key] = value;
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
const MS_IN_A_YEAR = 31536000000;
|
|
|
|
class FakeTimers {
|
|
constructor({global, moduleMocker, timerConfig, config, maxLoops}) {
|
|
_defineProperty(this, '_cancelledTicks', void 0);
|
|
|
|
_defineProperty(this, '_config', void 0);
|
|
|
|
_defineProperty(this, '_disposed', void 0);
|
|
|
|
_defineProperty(this, '_fakeTimerAPIs', void 0);
|
|
|
|
_defineProperty(this, '_global', void 0);
|
|
|
|
_defineProperty(this, '_immediates', void 0);
|
|
|
|
_defineProperty(this, '_maxLoops', void 0);
|
|
|
|
_defineProperty(this, '_moduleMocker', void 0);
|
|
|
|
_defineProperty(this, '_now', void 0);
|
|
|
|
_defineProperty(this, '_ticks', void 0);
|
|
|
|
_defineProperty(this, '_timerAPIs', void 0);
|
|
|
|
_defineProperty(this, '_timers', void 0);
|
|
|
|
_defineProperty(this, '_uuidCounter', void 0);
|
|
|
|
_defineProperty(this, '_timerConfig', void 0);
|
|
|
|
this._global = global;
|
|
this._timerConfig = timerConfig;
|
|
this._config = config;
|
|
this._maxLoops = maxLoops || 100000;
|
|
this._uuidCounter = 1;
|
|
this._moduleMocker = moduleMocker; // Store original timer APIs for future reference
|
|
|
|
this._timerAPIs = {
|
|
cancelAnimationFrame: global.cancelAnimationFrame,
|
|
clearImmediate: global.clearImmediate,
|
|
clearInterval: global.clearInterval,
|
|
clearTimeout: global.clearTimeout,
|
|
nextTick: global.process && global.process.nextTick,
|
|
requestAnimationFrame: global.requestAnimationFrame,
|
|
setImmediate: global.setImmediate,
|
|
setInterval: global.setInterval,
|
|
setTimeout: global.setTimeout
|
|
};
|
|
this.reset();
|
|
}
|
|
|
|
clearAllTimers() {
|
|
this._immediates = [];
|
|
|
|
this._timers.clear();
|
|
}
|
|
|
|
dispose() {
|
|
this._disposed = true;
|
|
this.clearAllTimers();
|
|
}
|
|
|
|
reset() {
|
|
this._cancelledTicks = {};
|
|
this._now = 0;
|
|
this._ticks = [];
|
|
this._immediates = [];
|
|
this._timers = new Map();
|
|
}
|
|
|
|
runAllTicks() {
|
|
this._checkFakeTimers(); // Only run a generous number of ticks and then bail.
|
|
// This is just to help avoid recursive loops
|
|
|
|
let i;
|
|
|
|
for (i = 0; i < this._maxLoops; i++) {
|
|
const tick = this._ticks.shift();
|
|
|
|
if (tick === undefined) {
|
|
break;
|
|
}
|
|
|
|
if (!this._cancelledTicks.hasOwnProperty(tick.uuid)) {
|
|
// Callback may throw, so update the map prior calling.
|
|
this._cancelledTicks[tick.uuid] = true;
|
|
tick.callback();
|
|
}
|
|
}
|
|
|
|
if (i === this._maxLoops) {
|
|
throw new Error(
|
|
'Ran ' +
|
|
this._maxLoops +
|
|
' ticks, and there are still more! ' +
|
|
"Assuming we've hit an infinite recursion and bailing out..."
|
|
);
|
|
}
|
|
}
|
|
|
|
runAllImmediates() {
|
|
this._checkFakeTimers(); // Only run a generous number of immediates and then bail.
|
|
|
|
let i;
|
|
|
|
for (i = 0; i < this._maxLoops; i++) {
|
|
const immediate = this._immediates.shift();
|
|
|
|
if (immediate === undefined) {
|
|
break;
|
|
}
|
|
|
|
this._runImmediate(immediate);
|
|
}
|
|
|
|
if (i === this._maxLoops) {
|
|
throw new Error(
|
|
'Ran ' +
|
|
this._maxLoops +
|
|
' immediates, and there are still more! Assuming ' +
|
|
"we've hit an infinite recursion and bailing out..."
|
|
);
|
|
}
|
|
}
|
|
|
|
_runImmediate(immediate) {
|
|
try {
|
|
immediate.callback();
|
|
} finally {
|
|
this._fakeClearImmediate(immediate.uuid);
|
|
}
|
|
}
|
|
|
|
runAllTimers() {
|
|
this._checkFakeTimers();
|
|
|
|
this.runAllTicks();
|
|
this.runAllImmediates(); // Only run a generous number of timers and then bail.
|
|
// This is just to help avoid recursive loops
|
|
|
|
let i;
|
|
|
|
for (i = 0; i < this._maxLoops; i++) {
|
|
const nextTimerHandle = this._getNextTimerHandle(); // If there are no more timer handles, stop!
|
|
|
|
if (nextTimerHandle === null) {
|
|
break;
|
|
}
|
|
|
|
this._runTimerHandle(nextTimerHandle); // Some of the immediate calls could be enqueued
|
|
// during the previous handling of the timers, we should
|
|
// run them as well.
|
|
|
|
if (this._immediates.length) {
|
|
this.runAllImmediates();
|
|
}
|
|
|
|
if (this._ticks.length) {
|
|
this.runAllTicks();
|
|
}
|
|
}
|
|
|
|
if (i === this._maxLoops) {
|
|
throw new Error(
|
|
'Ran ' +
|
|
this._maxLoops +
|
|
' timers, and there are still more! ' +
|
|
"Assuming we've hit an infinite recursion and bailing out..."
|
|
);
|
|
}
|
|
}
|
|
|
|
runOnlyPendingTimers() {
|
|
// We need to hold the current shape of `this._timers` because existing
|
|
// timers can add new ones to the map and hence would run more than necessary.
|
|
// See https://github.com/facebook/jest/pull/4608 for details
|
|
const timerEntries = Array.from(this._timers.entries());
|
|
|
|
this._checkFakeTimers();
|
|
|
|
this._immediates.forEach(this._runImmediate, this);
|
|
|
|
timerEntries
|
|
.sort(([, left], [, right]) => left.expiry - right.expiry)
|
|
.forEach(([timerHandle]) => this._runTimerHandle(timerHandle));
|
|
}
|
|
|
|
advanceTimersToNextTimer(steps = 1) {
|
|
if (steps < 1) {
|
|
return;
|
|
}
|
|
|
|
const nextExpiry = Array.from(this._timers.values()).reduce(
|
|
(minExpiry, timer) => {
|
|
if (minExpiry === null || timer.expiry < minExpiry) return timer.expiry;
|
|
return minExpiry;
|
|
},
|
|
null
|
|
);
|
|
|
|
if (nextExpiry !== null) {
|
|
this.advanceTimersByTime(nextExpiry - this._now);
|
|
this.advanceTimersToNextTimer(steps - 1);
|
|
}
|
|
}
|
|
|
|
advanceTimersByTime(msToRun) {
|
|
this._checkFakeTimers(); // Only run a generous number of timers and then bail.
|
|
// This is just to help avoid recursive loops
|
|
|
|
let i;
|
|
|
|
for (i = 0; i < this._maxLoops; i++) {
|
|
const timerHandle = this._getNextTimerHandle(); // If there are no more timer handles, stop!
|
|
|
|
if (timerHandle === null) {
|
|
break;
|
|
}
|
|
|
|
const timerValue = this._timers.get(timerHandle);
|
|
|
|
if (timerValue === undefined) {
|
|
break;
|
|
}
|
|
|
|
const nextTimerExpiry = timerValue.expiry;
|
|
|
|
if (this._now + msToRun < nextTimerExpiry) {
|
|
// There are no timers between now and the target we're running to, so
|
|
// adjust our time cursor and quit
|
|
this._now += msToRun;
|
|
break;
|
|
} else {
|
|
msToRun -= nextTimerExpiry - this._now;
|
|
this._now = nextTimerExpiry;
|
|
|
|
this._runTimerHandle(timerHandle);
|
|
}
|
|
}
|
|
|
|
if (i === this._maxLoops) {
|
|
throw new Error(
|
|
'Ran ' +
|
|
this._maxLoops +
|
|
' timers, and there are still more! ' +
|
|
"Assuming we've hit an infinite recursion and bailing out..."
|
|
);
|
|
}
|
|
}
|
|
|
|
runWithRealTimers(cb) {
|
|
const prevClearImmediate = this._global.clearImmediate;
|
|
const prevClearInterval = this._global.clearInterval;
|
|
const prevClearTimeout = this._global.clearTimeout;
|
|
const prevNextTick = this._global.process.nextTick;
|
|
const prevSetImmediate = this._global.setImmediate;
|
|
const prevSetInterval = this._global.setInterval;
|
|
const prevSetTimeout = this._global.setTimeout;
|
|
this.useRealTimers();
|
|
let cbErr = null;
|
|
let errThrown = false;
|
|
|
|
try {
|
|
cb();
|
|
} catch (e) {
|
|
errThrown = true;
|
|
cbErr = e;
|
|
}
|
|
|
|
this._global.clearImmediate = prevClearImmediate;
|
|
this._global.clearInterval = prevClearInterval;
|
|
this._global.clearTimeout = prevClearTimeout;
|
|
this._global.process.nextTick = prevNextTick;
|
|
this._global.setImmediate = prevSetImmediate;
|
|
this._global.setInterval = prevSetInterval;
|
|
this._global.setTimeout = prevSetTimeout;
|
|
|
|
if (errThrown) {
|
|
throw cbErr;
|
|
}
|
|
}
|
|
|
|
useRealTimers() {
|
|
const global = this._global;
|
|
|
|
if (typeof global.cancelAnimationFrame === 'function') {
|
|
(0, _jestUtil().setGlobal)(
|
|
global,
|
|
'cancelAnimationFrame',
|
|
this._timerAPIs.cancelAnimationFrame
|
|
);
|
|
}
|
|
|
|
if (typeof global.clearImmediate === 'function') {
|
|
(0, _jestUtil().setGlobal)(
|
|
global,
|
|
'clearImmediate',
|
|
this._timerAPIs.clearImmediate
|
|
);
|
|
}
|
|
|
|
(0, _jestUtil().setGlobal)(
|
|
global,
|
|
'clearInterval',
|
|
this._timerAPIs.clearInterval
|
|
);
|
|
(0, _jestUtil().setGlobal)(
|
|
global,
|
|
'clearTimeout',
|
|
this._timerAPIs.clearTimeout
|
|
);
|
|
|
|
if (typeof global.requestAnimationFrame === 'function') {
|
|
(0, _jestUtil().setGlobal)(
|
|
global,
|
|
'requestAnimationFrame',
|
|
this._timerAPIs.requestAnimationFrame
|
|
);
|
|
}
|
|
|
|
if (typeof global.setImmediate === 'function') {
|
|
(0, _jestUtil().setGlobal)(
|
|
global,
|
|
'setImmediate',
|
|
this._timerAPIs.setImmediate
|
|
);
|
|
}
|
|
|
|
(0, _jestUtil().setGlobal)(
|
|
global,
|
|
'setInterval',
|
|
this._timerAPIs.setInterval
|
|
);
|
|
(0, _jestUtil().setGlobal)(
|
|
global,
|
|
'setTimeout',
|
|
this._timerAPIs.setTimeout
|
|
);
|
|
global.process.nextTick = this._timerAPIs.nextTick;
|
|
}
|
|
|
|
useFakeTimers() {
|
|
this._createMocks();
|
|
|
|
const global = this._global;
|
|
|
|
if (typeof global.cancelAnimationFrame === 'function') {
|
|
(0, _jestUtil().setGlobal)(
|
|
global,
|
|
'cancelAnimationFrame',
|
|
this._fakeTimerAPIs.cancelAnimationFrame
|
|
);
|
|
}
|
|
|
|
if (typeof global.clearImmediate === 'function') {
|
|
(0, _jestUtil().setGlobal)(
|
|
global,
|
|
'clearImmediate',
|
|
this._fakeTimerAPIs.clearImmediate
|
|
);
|
|
}
|
|
|
|
(0, _jestUtil().setGlobal)(
|
|
global,
|
|
'clearInterval',
|
|
this._fakeTimerAPIs.clearInterval
|
|
);
|
|
(0, _jestUtil().setGlobal)(
|
|
global,
|
|
'clearTimeout',
|
|
this._fakeTimerAPIs.clearTimeout
|
|
);
|
|
|
|
if (typeof global.requestAnimationFrame === 'function') {
|
|
(0, _jestUtil().setGlobal)(
|
|
global,
|
|
'requestAnimationFrame',
|
|
this._fakeTimerAPIs.requestAnimationFrame
|
|
);
|
|
}
|
|
|
|
if (typeof global.setImmediate === 'function') {
|
|
(0, _jestUtil().setGlobal)(
|
|
global,
|
|
'setImmediate',
|
|
this._fakeTimerAPIs.setImmediate
|
|
);
|
|
}
|
|
|
|
(0, _jestUtil().setGlobal)(
|
|
global,
|
|
'setInterval',
|
|
this._fakeTimerAPIs.setInterval
|
|
);
|
|
(0, _jestUtil().setGlobal)(
|
|
global,
|
|
'setTimeout',
|
|
this._fakeTimerAPIs.setTimeout
|
|
);
|
|
global.process.nextTick = this._fakeTimerAPIs.nextTick;
|
|
}
|
|
|
|
getTimerCount() {
|
|
this._checkFakeTimers();
|
|
|
|
return this._timers.size + this._immediates.length + this._ticks.length;
|
|
}
|
|
|
|
_checkFakeTimers() {
|
|
var _this$_fakeTimerAPIs;
|
|
|
|
if (
|
|
this._global.setTimeout !==
|
|
((_this$_fakeTimerAPIs = this._fakeTimerAPIs) === null ||
|
|
_this$_fakeTimerAPIs === void 0
|
|
? void 0
|
|
: _this$_fakeTimerAPIs.setTimeout)
|
|
) {
|
|
this._global.console.warn(
|
|
'A function to advance timers was called but the timers API is not ' +
|
|
'mocked with fake timers. Call `jest.useFakeTimers()` in this ' +
|
|
'test or enable fake timers globally by setting ' +
|
|
'`"timers": "fake"` in ' +
|
|
'the configuration file. This warning is likely a result of a ' +
|
|
'default configuration change in Jest 15.\n\n' +
|
|
'Release Blog Post: https://jestjs.io/blog/2016/09/01/jest-15\n' +
|
|
'Stack Trace:\n' +
|
|
(0, _jestMessageUtil().formatStackTrace)(
|
|
new Error().stack,
|
|
this._config,
|
|
{
|
|
noStackTrace: false
|
|
}
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
_createMocks() {
|
|
const fn = (
|
|
impl // @ts-expect-error TODO: figure out better typings here
|
|
) => this._moduleMocker.fn().mockImplementation(impl);
|
|
|
|
const promisifiableFakeSetTimeout = fn(this._fakeSetTimeout.bind(this)); // @ts-expect-error TODO: figure out better typings here
|
|
|
|
promisifiableFakeSetTimeout[_util().default.promisify.custom] = (
|
|
delay,
|
|
arg
|
|
) =>
|
|
new Promise(resolve => promisifiableFakeSetTimeout(resolve, delay, arg)); // TODO: add better typings; these are mocks, but typed as regular timers
|
|
|
|
this._fakeTimerAPIs = {
|
|
cancelAnimationFrame: fn(this._fakeClearTimer.bind(this)),
|
|
clearImmediate: fn(this._fakeClearImmediate.bind(this)),
|
|
clearInterval: fn(this._fakeClearTimer.bind(this)),
|
|
clearTimeout: fn(this._fakeClearTimer.bind(this)),
|
|
nextTick: fn(this._fakeNextTick.bind(this)),
|
|
// @ts-expect-error TODO: figure out better typings here
|
|
requestAnimationFrame: fn(this._fakeRequestAnimationFrame.bind(this)),
|
|
// @ts-expect-error TODO: figure out better typings here
|
|
setImmediate: fn(this._fakeSetImmediate.bind(this)),
|
|
// @ts-expect-error TODO: figure out better typings here
|
|
setInterval: fn(this._fakeSetInterval.bind(this)),
|
|
// @ts-expect-error TODO: figure out better typings here
|
|
setTimeout: promisifiableFakeSetTimeout
|
|
};
|
|
}
|
|
|
|
_fakeClearTimer(timerRef) {
|
|
const uuid = this._timerConfig.refToId(timerRef);
|
|
|
|
if (uuid) {
|
|
this._timers.delete(String(uuid));
|
|
}
|
|
}
|
|
|
|
_fakeClearImmediate(uuid) {
|
|
this._immediates = this._immediates.filter(
|
|
immediate => immediate.uuid !== uuid
|
|
);
|
|
}
|
|
|
|
_fakeNextTick(callback, ...args) {
|
|
if (this._disposed) {
|
|
return;
|
|
}
|
|
|
|
const uuid = String(this._uuidCounter++);
|
|
|
|
this._ticks.push({
|
|
callback: () => callback.apply(null, args),
|
|
uuid
|
|
});
|
|
|
|
const cancelledTicks = this._cancelledTicks;
|
|
|
|
this._timerAPIs.nextTick(() => {
|
|
if (!cancelledTicks.hasOwnProperty(uuid)) {
|
|
// Callback may throw, so update the map prior calling.
|
|
cancelledTicks[uuid] = true;
|
|
callback.apply(null, args);
|
|
}
|
|
});
|
|
}
|
|
|
|
_fakeRequestAnimationFrame(callback) {
|
|
return this._fakeSetTimeout(() => {
|
|
// TODO: Use performance.now() once it's mocked
|
|
callback(this._now);
|
|
}, 1000 / 60);
|
|
}
|
|
|
|
_fakeSetImmediate(callback, ...args) {
|
|
if (this._disposed) {
|
|
return null;
|
|
}
|
|
|
|
const uuid = String(this._uuidCounter++);
|
|
|
|
this._immediates.push({
|
|
callback: () => callback.apply(null, args),
|
|
uuid
|
|
});
|
|
|
|
this._timerAPIs.setImmediate(() => {
|
|
if (this._immediates.find(x => x.uuid === uuid)) {
|
|
try {
|
|
callback.apply(null, args);
|
|
} finally {
|
|
this._fakeClearImmediate(uuid);
|
|
}
|
|
}
|
|
});
|
|
|
|
return uuid;
|
|
}
|
|
|
|
_fakeSetInterval(callback, intervalDelay, ...args) {
|
|
if (this._disposed) {
|
|
return null;
|
|
}
|
|
|
|
if (intervalDelay == null) {
|
|
intervalDelay = 0;
|
|
}
|
|
|
|
const uuid = this._uuidCounter++;
|
|
|
|
this._timers.set(String(uuid), {
|
|
callback: () => callback.apply(null, args),
|
|
expiry: this._now + intervalDelay,
|
|
interval: intervalDelay,
|
|
type: 'interval'
|
|
});
|
|
|
|
return this._timerConfig.idToRef(uuid);
|
|
}
|
|
|
|
_fakeSetTimeout(callback, delay, ...args) {
|
|
if (this._disposed) {
|
|
return null;
|
|
} // eslint-disable-next-line no-bitwise
|
|
|
|
delay = Number(delay) | 0;
|
|
const uuid = this._uuidCounter++;
|
|
|
|
this._timers.set(String(uuid), {
|
|
callback: () => callback.apply(null, args),
|
|
expiry: this._now + delay,
|
|
interval: undefined,
|
|
type: 'timeout'
|
|
});
|
|
|
|
return this._timerConfig.idToRef(uuid);
|
|
}
|
|
|
|
_getNextTimerHandle() {
|
|
let nextTimerHandle = null;
|
|
let soonestTime = MS_IN_A_YEAR;
|
|
|
|
this._timers.forEach((timer, uuid) => {
|
|
if (timer.expiry < soonestTime) {
|
|
soonestTime = timer.expiry;
|
|
nextTimerHandle = uuid;
|
|
}
|
|
});
|
|
|
|
return nextTimerHandle;
|
|
}
|
|
|
|
_runTimerHandle(timerHandle) {
|
|
const timer = this._timers.get(timerHandle);
|
|
|
|
if (!timer) {
|
|
return;
|
|
}
|
|
|
|
switch (timer.type) {
|
|
case 'timeout':
|
|
this._timers.delete(timerHandle);
|
|
|
|
timer.callback();
|
|
break;
|
|
|
|
case 'interval':
|
|
timer.expiry = this._now + (timer.interval || 0);
|
|
timer.callback();
|
|
break;
|
|
|
|
default:
|
|
throw new Error('Unexpected timer type: ' + timer.type);
|
|
}
|
|
}
|
|
}
|
|
|
|
exports.default = FakeTimers;
|