Jest 对象

Jest 对象

jest 对象会自动注入到每个测试文件中， jest 对象上的方法帮助你创建模拟并让你控制 Jest 的整体行为。也可以通过 import { jest } from '@jest/globals' 手动进行引入。

信息

The TypeScript examples from this page will only work as documented if you explicitly import Jest APIs:

import {expect, jest, test} from '@jest/globals';

Consult the Getting Started guide for details on how to setup Jest with TypeScript.

Mock Modules

`jest.disableAutomock()`

Disables automatic mocking in the module loader.

信息

Automatic mocking should be enabled via automock configuration option for this method to have any effect. Also see documentation of the configuration option for more details.

JavaScript
TypeScript

/** @type {import('jest').Config} */
const config = {
  automock: true,
};
module.exports = config;

import type {Config} from 'jest';
const config: Config = {
  automock: true,
};
export default config;

After disableAutomock() is called, all require()s will return the real versions of each module (rather than a mocked version).

utils.js

export default {
  authorize: () => {
    return 'token';
  },
};

__tests__/disableAutomocking.js

import utils from '../utils';
jest.disableAutomock();
test('original implementation', () => {
  // now we have the original implementation,
  // even if we set the automocking in a jest configuration
  expect(utils.authorize()).toBe('token');
});

This is usually useful when you have a scenario where the number of dependencies you want to mock is far less than the number of dependencies that you don’t. For example, if you’re writing a test for a module that uses a large number of dependencies that can be reasonably classified as “implementation details” of the module, then you likely do not want to mock them. For example, if you’re writing a test for a module that uses a large number of dependencies that can be reasonably classified as “implementation details” of the module, then you likely do not want to mock them.

Examples of dependencies that might be considered “implementation details” are things ranging from language built-ins (e.g. Array.prototype methods) to highly common utility methods (e.g. underscore, lodash, array utilities, etc) and entire libraries like React.js.

返回 jest 对象进行链式操作。

提示

When using babel-jest, calls to disableAutomock() will automatically be hoisted to the top of the code block. Use autoMockOff() if you want to explicitly avoid this behavior.

`jest.enableAutomock()`

Enables automatic mocking in the module loader.

信息

For more details on automatic mocking see documentation of automock configuration option.

示例：

utils.js

export default {
  authorize: () => {
    return 'token';
  },
  isAuthorized: secret => secret === 'wizard',
};

__tests__/enableAutomocking.js

jest.enableAutomock();
import utils from '../utils';
test('original implementation', () => {
  // now we have the mocked implementation,
  expect(utils.authorize._isMockFunction).toBeTruthy();
  expect(utils.isAuthorized._isMockFunction).toBeTruthy();
});

返回 jest 对象进行链式操作。

提示

When using babel-jest, calls to enableAutomock will automatically be hoisted to the top of the code block. Use autoMockOn if you want to explicitly avoid this behavior.

`jest.createMockFromModule(moduleName)`

Given the name of a module, use the automatic mocking system to generate a mocked version of the module for you.

This is useful when you want to create a manual mock that extends the automatic mock’s behavior:

JavaScript
TypeScript

utils.js

module.exports = {
  authorize: () => {
    return 'token';
  },
  isAuthorized: secret => secret === 'wizard',
};

__tests__/createMockFromModule.test.js

const utils = jest.createMockFromModule('../utils');
utils.isAuthorized = jest.fn(secret => secret === 'not wizard');
test('implementation created by jest.createMockFromModule', () => {
  expect(jest.isMockFunction(utils.authorize)).toBe(true);
  expect(utils.isAuthorized('not wizard')).toBe(true);
});

utils.ts

export const utils = {
  authorize: () => {
    return 'token';
  },
  isAuthorized: (secret: string) => secret === 'wizard',
};

__tests__/createMockFromModule.test.ts

const {utils} =
  jest.createMockFromModule<typeof import('../utils')>('../utils');
utils.isAuthorized = jest.fn((secret: string) => secret === 'not wizard');
test('implementation created by jest.createMockFromModule', () => {
  expect(jest.isMockFunction(utils.authorize)).toBe(true);
  expect(utils.isAuthorized('not wizard')).toBe(true);
});

This is how createMockFromModule will mock the following data types:

`函数`

Creates a new mock function. The new function has no formal parameters and when called will return undefined. This functionality also applies to async functions.

`类`

Creates a new class. Creates a new class. The interface of the original class is maintained, all of the class member functions and properties will be mocked.

`对象`

Creates a new deeply cloned object. Creates a new deeply cloned object. The object keys are maintained and their values are mocked.

`数组`

Creates a new empty array, ignoring the original.

`基本类型`

Creates a new property with the same primitive value as the original property.

示例：

example.js

module.exports = {
  function: function square(a, b) {
    return a * b;
  },
  asyncFunction: async function asyncSquare(a, b) {
    const result = (await a) * b;
    return result;
  },
  class: new (class Bar {
    constructor() {
      this.array = [1, 2, 3];
    }
    foo() {}
  })(),
  object: {
    baz: 'foo',
    bar: {
      fiz: 1,
      buzz: [1, 2, 3],
    },
  },
  array: [1, 2, 3],
  number: 123,
  string: 'baz',
  boolean: true,
  symbol: Symbol.for('a.b.c'),
};

__tests__/example.test.js

const example = jest.createMockFromModule('../example');
test('should run example code', () => {
  // creates a new mocked function with no formal arguments.
  expect(example.function.name).toBe('square');
  expect(example.function).toHaveLength(0);
  // async functions get the same treatment as standard synchronous functions.
  expect(example.asyncFunction.name).toBe('asyncSquare');
  expect(example.asyncFunction).toHaveLength(0);
  // creates a new class with the same interface, member functions and properties are mocked.
  expect(example.class.constructor.name).toBe('Bar');
  expect(example.class.foo.name).toBe('foo');
  expect(example.class.array).toHaveLength(0);
  // creates a deeply cloned version of the original object.
  expect(example.object).toEqual({
    baz: 'foo',
    bar: {
      fiz: 1,
      buzz: [],
    },
  });
  // creates a new empty array, ignoring the original array.
  expect(example.array).toHaveLength(0);
  // creates a new property with the same primitive value as the original property.
  expect(example.number).toBe(123);
  expect(example.string).toBe('baz');
  expect(example.boolean).toBe(true);
  expect(example.symbol).toEqual(Symbol.for('a.b.c'));
});

`jest.mock(moduleName, factory, options)`

Mocks a module with an auto-mocked version when it is being required. factory and options are optional. For example: factory and options are optional. 例如：

banana.js

module.exports = () => 'banana';

__tests__/test.js

jest.mock('../banana');
const banana = require('../banana'); // banana will be explicitly mocked.
banana(); // will return 'undefined' because the function is auto-mocked.

The second argument can be used to specify an explicit module factory that is being run instead of using Jest’s automocking feature:

JavaScript
TypeScript

jest.mock('../moduleName', () => {
  return jest.fn(() => 42);
});
// This runs the function specified as second argument to `jest.mock`.
const moduleName = require('../moduleName');
moduleName(); // Will return '42';
const moduleName = require('../moduleName');
moduleName(); // Will return '42';

// The optional type argument provides typings for the module factory
jest.mock<typeof import('../moduleName')>('../moduleName', () => {
  return jest.fn(() => 42);
});
// This runs the function specified as second argument to `jest.mock`.
const moduleName = require('../moduleName');
moduleName(); // Will return '42';

When using the factory parameter for an ES6 module with a default export, the __esModule: true property needs to be specified. This property is normally generated by Babel / TypeScript, but here it needs to be set manually. When importing a default export, it’s an instruction to import the property named default from the export object: This property is normally generated by Babel / TypeScript, but here it needs to be set manually. When importing a default export, it’s an instruction to import the property named default from the export object:

import moduleName, {foo} from '../moduleName';
jest.mock('../moduleName', () => {
  return {
    __esModule: true,
    default: jest.fn(() => 42),
    foo: jest.fn(() => 43),
  };
});
moduleName(); // Will return 42
foo(); // Will return 43

The third argument can be used to create virtual mocks – mocks of modules that don’t exist anywhere in the system:

jest.mock(
  '../moduleName',
  () => {
    /*
     * Custom implementation of a module that doesn't exist in JS,
     * like a generated module or a native module in react-native.
     */
  },
  {virtual: true},
);
     */
  },
  {virtual: true},
);

注意

Importing a module in a setup file (as specified by setupFilesAfterEnv) will prevent mocking for the module in question, as well as all the modules that it imports.

Modules that are mocked with jest.mock are mocked only for the file that calls jest.mock. Another file that imports the module will get the original implementation even if it runs after the test file that mocks the module. Another file that imports the module will get the original implementation even if it runs after the test file that mocks the module.

返回 jest 对象进行链式操作。

提示

Writing tests in TypeScript? Use the jest.Mocked utility type or the jest.mocked() helper method to have your mocked modules typed.

`jest.Mocked<Source>`

See TypeScript Usage chapter of Mock Functions page for documentation.

`jest.mocked(source, options?)`

See TypeScript Usage chapter of Mock Functions page for documentation.

`jest.unmock(moduleName)`

Indicates that the module system should never return a mocked version of the specified module from require() (e.g. that it should always return the real module).

The most common use of this API is for specifying the module a given test intends to be testing (and thus doesn’t want automatically mocked).

返回 jest 对象进行链式操作。

`jest.deepUnmock(moduleName)`

Indicates that the module system should never return a mocked version of the specified module and its dependencies.

返回 jest 对象进行链式操作。

`jest.doMock(moduleName, factory, options)`

When using babel-jest, calls to mock will automatically be hoisted to the top of the code block. Use this method if you want to explicitly avoid this behavior.

One example when this is useful is when you want to mock a module differently within the same file:

JavaScript
TypeScript

beforeEach(() => {
  jest.resetModules();
});
test('moduleName 1', () => {
  jest.doMock('../moduleName', () => {
    return jest.fn(() => 1);
  });
  const moduleName = require('../moduleName');
  expect(moduleName()).toBe(1);
});
test('moduleName 2', () => {
  jest.doMock('../moduleName', () => {
    return jest.fn(() => 2);
  });
  const moduleName = require('../moduleName');
  expect(moduleName()).toBe(2);
});

beforeEach(() => {
  jest.resetModules();
});
test('moduleName 1', () => {
  // The optional type argument provides typings for the module factory
  jest.doMock<typeof import('../moduleName')>('../moduleName', () => {
    return jest.fn(() => 1);
  });
  const moduleName = require('../moduleName');
  expect(moduleName()).toBe(1);
});
test('moduleName 2', () => {
  jest.doMock<typeof import('../moduleName')>('../moduleName', () => {
    return jest.fn(() => 2);
  });
  const moduleName = require('../moduleName');
  expect(moduleName()).toBe(2);
});

Using jest.doMock() with ES6 imports requires additional steps. Follow these if you don’t want to use require in your tests: Follow these if you don’t want to use require in your tests:

必须指定 __esModule: true 属性（见 jest.mock() API以获取更多信息）
静态的 ES6 模块导入语句将会被置于文件顶部，所以应该使用 import() 进行模块的动态导入
最后，需要一个支持动态导入的环境。请查看使用 Babel 进行初始设置。然后添加 babel-plugin-dynamic-import-node 插件或者其他有相同功能的插件来确保 Babel 开启了在 Node 中动态导入的配置。

beforeEach(() => {
  jest.resetModules();
});
test('moduleName 1', () => {
  jest.doMock('../moduleName', () => {
    return {
      __esModule: true,
      default: 'default1',
      foo: 'foo1',
    };
  });
  return import('../moduleName').then(moduleName => {
    expect(moduleName.default).toBe('default1');
    expect(moduleName.foo).toBe('foo1');
  });
});
test('moduleName 2', () => {
  jest.doMock('../moduleName', () => {
    return {
      __esModule: true,
      default: 'default2',
      foo: 'foo2',
    };
  });
  return import('../moduleName').then(moduleName => {
    expect(moduleName.default).toBe('default2');
    expect(moduleName.foo).toBe('foo2');
  });
});

返回 jest 对象进行链式操作。

`jest.dontMock(moduleName)`

When using babel-jest, calls to unmock will automatically be hoisted to the top of the code block. Use this method if you want to explicitly avoid this behavior. Use this method if you want to explicitly avoid this behavior.

返回 jest 对象进行链式操作。

`jest.setMock(moduleName, moduleExports)`

Explicitly supplies the mock object that the module system should return for the specified module.

On occasion, there are times where the automatically generated mock the module system would normally provide you isn’t adequate enough for your testing needs. On occasion, there are times where the automatically generated mock the module system would normally provide you isn’t adequate enough for your testing needs. Normally under those circumstances you should write a manual mock that is more adequate for the module in question. However, on extremely rare occasions, even a manual mock isn’t suitable for your purposes and you need to build the mock yourself inside your test. However, on extremely rare occasions, even a manual mock isn’t suitable for your purposes and you need to build the mock yourself inside your test.

In these rare scenarios you can use this API to manually fill the slot in the module system’s mock-module registry.

返回 jest 对象进行链式操作。

信息

It is recommended to use jest.mock() instead. The jest.mock API’s second argument is a module factory instead of the expected exported module object.

`jest.requireActual(moduleName)`

Returns the actual module instead of a mock, bypassing all checks on whether the module should receive a mock implementation or not.

JavaScript
TypeScript

jest.mock('../myModule', () => {
  // Require the original module to not be mocked...
  const originalModule = jest.requireActual('../myModule');
  return {
    __esModule: true, // Use it when dealing with esModules
    ...originalModule,
    getRandom: jest.fn(() => 10),
  };
});
const getRandom = require('../myModule').getRandom;
getRandom(); // Always returns 10

jest.mock('../myModule', () => {
  // Require the original module to not be mocked...
  const originalModule =
    jest.requireActual<typeof import('../myModule')>('../myModule');
  return {
    __esModule: true, // Use it when dealing with esModules
    ...originalModule,
    getRandom: jest.fn(() => 10),
  };
});
const getRandom = require('../myModule').getRandom;
getRandom(); // Always returns 10

`jest.requireMock(moduleName)`

Returns a mock module instead of the actual module, bypassing all checks on whether the module should be required normally or not.

`jest.resetModules()`

Resets the module registry - the cache of all required modules. Resets the module registry - the cache of all required modules. This is useful to isolate modules where local state might conflict between tests.

示例：

const sum1 = require('../sum');
jest.resetModules();
const sum2 = require('../sum');
sum1 === sum2;
// > false (Both sum modules are separate "instances" of the sum module.)

Example in a test:

beforeEach(() => {
  jest.resetModules();
});
test('works', () => {
  const sum = require('../sum');
});
test('works too', () => {
  const sum = require('../sum');
  // sum is a different copy of the sum module from the previous test.
});
});

返回 jest 对象进行链式操作。

`jest.isolateModules(fn)`

jest.isolateModules(fn) goes a step further than jest.resetModules() and creates a sandbox registry for the modules that are loaded inside the callback function. This is useful to isolate specific modules for every test so that local module state doesn’t conflict between tests. This is useful to isolate specific modules for every test so that local module state doesn’t conflict between tests.

let myModule;
jest.isolateModules(() => {
  myModule = require('myModule');
});
const otherCopyOfMyModule = require('myModule');

`jest.isolateModulesAsync(fn)`

jest.isolateModulesAsync() is the equivalent of jest.isolateModules(), but for async callbacks. The caller is expected to await the completion of isolateModulesAsync.

let myModule;
await jest.isolateModulesAsync(async () => {
  myModule = await import('myModule');
  // do async stuff here
});
const otherCopyOfMyModule = await import('myModule');

模拟函数

`jest.fn(implementation?)`

Returns a new, unused mock function. Optionally takes a mock implementation. Optionally takes a mock implementation.

const mockFn = jest.fn();
mockFn();
expect(mockFn).toHaveBeenCalled();
// With a mock implementation:
const returnsTrue = jest.fn(() => true);
console.log(returnsTrue()); // true;

提示

See the Mock Functions page for details on TypeScript usage.

`jest.isMockFunction(fn)`

Determines if the given function is a mocked function.

`jest.replaceProperty(object, propertyKey, value)`

Replace object[propertyKey] with a value. The property must already exist on the object. The same property might be replaced multiple times. Returns a Jest replaced property.

备注

To mock properties that are defined as getters or setters, use jest.spyOn(object, methodName, accessType) instead. To mock functions, use jest.spyOn(object, methodName) instead.

提示

All properties replaced with jest.replaceProperty could be restored to the original value by calling jest.restoreAllMocks on afterEach method.

示例：

const utils = {
  isLocalhost() {
    return process.env.HOSTNAME === 'localhost';
  },
};
module.exports = utils;

Example test:

const utils = require('./utils');
afterEach(() => {
  // restore replaced property
  jest.restoreAllMocks();
});
test('isLocalhost returns true when HOSTNAME is localhost', () => {
  jest.replaceProperty(process, 'env', {HOSTNAME: 'localhost'});
  expect(utils.isLocalhost()).toBe(true);
});
test('isLocalhost returns false when HOSTNAME is not localhost', () => {
  jest.replaceProperty(process, 'env', {HOSTNAME: 'not-localhost'});
  expect(utils.isLocalhost()).toBe(false);
});

`jest.spyOn(object, methodName)`

Creates a mock function similar to jest.fn but also tracks calls to object[methodName]. Returns a Jest mock function. Returns a Jest mock function.

备注

By default, jest.spyOn also calls the spied method. This is different behavior from most other test libraries. If you want to overwrite the original function, you can use jest.spyOn(object, methodName).mockImplementation(() => customImplementation) or object[methodName] = jest.fn(() => customImplementation).

提示

Since jest.spyOn is a mock, you could restore the initial state by calling jest.restoreAllMocks in the body of the callback passed to the afterEach hook.

示例：

const video = {
  play() {
    return true;
  },
};
module.exports = video;

Example test:

const video = require('./video');
afterEach(() => {
  // restore the spy created with spyOn
  jest.restoreAllMocks();
});
test('plays video', () => {
  const spy = jest.spyOn(video, 'play');
  const isPlaying = video.play();
  expect(spy).toHaveBeenCalled();
  expect(isPlaying).toBe(true);
});

`jest.spyOn(object, methodName, accessType?)`

Since Jest 22.1.0+, the jest.spyOn method takes an optional third argument of accessType that can be either 'get' or 'set', which proves to be useful when you want to spy on a getter or a setter, respectively.

示例：

const video = {
  // it's a getter!
  const video = {
  // it's a getter!
  get play() {
    return true;
  },
};
module.exports = video;
const audio = {
  _volume: false,
  // it's a setter!
  set volume(value) {
    this._volume = value;
  },
  get volume() {
    return this._volume;
  },
};
module.exports = audio;
  set volume(value) {
    this._volume = value;
  },
  get volume() {
    return this._volume;
  },
};
module.exports = audio;

Example test:

const audio = require('./audio');
const video = require('./video');
afterEach(() => {
  // restore the spy created with spyOn
  jest.restoreAllMocks();
});
test('plays video', () => {
  const spy = jest.spyOn(video, 'play', 'get'); // we pass 'get'
  const isPlaying = video.play;
  expect(spy).toHaveBeenCalled();
  expect(isPlaying).toBe(true);
});
test('plays audio', () => {
  const spy = jest.spyOn(audio, 'volume', 'set'); // we pass 'set'
  audio.volume = 100;
  expect(spy).toHaveBeenCalled();
  expect(audio.volume).toBe(100);
});

`jest.Replaced<Source>`

See TypeScript Usage chapter of Mock Functions page for documentation.

`jest.Spied<Source>`

See TypeScript Usage chapter of Mock Functions page for documentation.

`jest.clearAllMocks()`

清除所有模拟的属性： mock.calls, mock.instances, mock.context 和 mock.results 。 Clears the mock.calls and mock.instances properties of all mocks. Equivalent to calling .mockClear() on every mocked function.

返回 jest 对象进行链式操作。

`jest.resetAllMocks()`

Resets the state of all mocks. Resets the state of all mocks. Equivalent to calling .mockReset() on every mocked function.

返回 jest 对象进行链式操作。

`jest.restoreAllMocks()`

Restores all mocks and replaced properties back to their original value. Equivalent to calling .mockRestore() on every mocked function and .restore() on every replaced property. Beware that jest.restoreAllMocks() only works for mocks created with jest.spyOn() and properties replaced with jest.replaceProperty(); other mocks will require you to manually restore them.

假的定时器

`jest.useFakeTimers(fakeTimersConfig?)`

指定 Jest 使用假的全局日期、性能、时间和定时器 API。假定时器实现由 @sinonjs/fake-timaters 支持。

假定时器会替换 Date, performance.now(), queueMicrotask(), setImmediate(), clearImmediate(), setInterval(), clearInterval(), setTimeout(), clearTimeout() 的实现从而获得假时间。

在 Node 环境下的 process.hrtime, process.nextTick() 和 JSDOM 环境下的 requestAnimationFrame(), cancelAnimationFrame(), requestIdleCallback(), cancelIdleCallback() 同样会被替换。

配置选项

type FakeableAPI =
  | 'Date'
  | 'hrtime'
  | 'nextTick'
  | 'performance'
  | 'queueMicrotask'
  | 'requestAnimationFrame'
  | 'cancelAnimationFrame'
  | 'requestIdleCallback'
  | 'cancelIdleCallback'
  | 'setImmediate'
  | 'clearImmediate'
  | 'setInterval'
  | 'clearInterval'
  | 'setTimeout'
  | 'clearTimeout';
type FakeTimersConfig = {
  /**
   * 如果设置为 true，所有定时器每隔20ms会提前20ms
   * 设置数字可以提供一个自定义的时间间隔
   * 默认为 false
   */
  advanceTimers?: boolean | number;
  /**
   * 传入不该被替换的API列表 默认是 [] 代表全部的API都被会替换
   */
  doNotFake?: Array<FakeableAPI>;
  /**
   * 使用原有的定时器实现而不是`@sinonjs/fake-timers`提供的
   * 默认为 false
   */
  legacyFakeTimers?: boolean;
  /** Sets current system time to be used by fake timers, in milliseconds. 默认值是 `Date.now ()`。 */
  now?: number | Date;
  /**
   * 调用 `jest.runAllTimers()`.时运行的定时器最大数量
   * 默认值是 `100_000` 计时器。
   */
  timerLimit?: number;
};

调用 jest.useFakeTimers() 将在所有测试中使用假定时器，直到调用jest.useRealTimers()恢复使用原定时器

可以在任何地方调用 jest.useFakeTimers() 或 jest.useRealTimers()(如顶层，it内部等)。请记住，这是一个 全局操作 ，并将影响到同一文件中的其他测试。在同一测试文件内再次调用 jest.useFakeTimers() 会重置内部状态（如计时器计数），并使用提供的选项重新载入假定时器替换原生的API。

test('advance the timers automatically', () => {
  jest.useFakeTimers({advanceTimers: true});
  // ...
});
test('do not advance the timers and do not fake `performance`', () => {
  jest.useFakeTimers({doNotFake: ['performance']});
  // ...
});
test('uninstall fake timers for the rest of tests in the file', () => {
  jest.useRealTimers();
  // ...
});

旧版本的假定时器

出于某些原因，你可能不得不使用旧版本的假定时器。可以像这样启用 (不支持其他选项)：

jest.useFakeTimers({
  legacyFakeTimers: true,
});

旧版本的假定时器使用 Jest mock functions 替换掉 setImmediate(), clearImmediate(), setInterval(), clearInterval(), setTimeout(), clearTimeout()，以及 Node 环境下的 process.nextTick() ，JSDOM 环境下的 requestAnimationFrame(), cancelAnimationFrame()

:::

返回 jest 对象进行链式操作。

`jest.useRealTimers()`

指定 Jest 使用真实的全局日期、性能、时间和定时器 API。比如，你可以在 afterEach 里调用 jest.useRealTimers() 实现每一次测试结束后恢复真实的定时器。

afterEach(() => {
  jest.useRealTimers();
});
test('do something with fake timers', () => {
  jest.useFakeTimers();
  // ...
});
test('do something with real timers', () => {
  // ...
});
});
test('do something with real timers', () => {
  // ...
});

返回 jest 对象进行链式操作。

`jest.runAllTicks()`

Exhausts the micro-task queue (usually interfaced in node via process.nextTick).

When this API is called, all pending micro-tasks that have been queued via process.nextTick will be executed. Additionally, if those micro-tasks themselves schedule new micro-tasks, those will be continually exhausted until there are no more micro-tasks remaining in the queue. Additionally, if those micro-tasks themselves schedule new micro-tasks, those will be continually exhausted until there are no more micro-tasks remaining in the queue.

`jest.runAllTimers()`

Exhausts both the macro-task queue (i.e., all tasks queued by setTimeout(), setInterval(), and setImmediate()) and the micro-task queue (usually interfaced in node via process.nextTick).

When this API is called, all pending macro-tasks and micro-tasks will be executed. If those tasks themselves schedule new tasks, those will be continually exhausted until there are no more tasks remaining in the queue. If those tasks themselves schedule new tasks, those will be continually exhausted until there are no more tasks remaining in the queue.

This is often useful for synchronously executing setTimeouts during a test in order to synchronously assert about some behavior that would only happen after the setTimeout() or setInterval() callbacks executed. See the Timer mocks doc for more information. See the Timer mocks doc for more information.

`jest.runAllTimersAsync()`

Asynchronous equivalent of jest.runAllTimers(). It allows any scheduled promise callbacks to execute before running the timers.

Set the current system time used by fake timers. Simulates a user changing the system clock while your program is running. Set the current system time used by fake timers. Simulates a user changing the system clock while your program is running. It affects the current time but it does not in itself cause e.g. timers to fire; they will fire exactly as they would have done without the call to jest.setSystemTime().

信息

此功能在使用旧的假定时器时不可用。

`jest.getRealSystemTime()`

When mocking time, Date.now() will also be mocked. If you for some reason need access to the real current time, you can invoke this function. If you for some reason need access to the real current time, you can invoke this function.

信息

此功能在使用旧的假定时器时不可用。

Misc

`jest.getSeed()`

Every time Jest runs a seed value is randomly generated which you could use in a pseudorandom number generator or anywhere else.

提示

Use the --showSeed flag to print the seed in the test report summary. To manually set the value of the seed use --seed= CLI argument.

`jest.isEnvironmentTornDown()`

Returns true if test environment has been torn down.

`jest.retryTimes(numRetries, options?)`

Runs failed tests n-times until they pass or until the max number of retries is exhausted.

jest.retryTimes(3);
test('will fail', () => {
  expect(true).toBe(false);
});

If logErrorsBeforeRetry option is enabled, error(s) that caused the test to fail will be logged to the console.

jest.retryTimes(3, {logErrorsBeforeRetry: true});
test('will fail', () => {
  expect(true).toBe(false);
});

返回 jest 对象进行链式操作。

注意

jest.retryTimes() must be declared at the top level of a test file or in a describe block.

信息

This function is only available with the default jest-circus runner.

`jest.setTimeout(timeout)`

Set the default timeout interval (in milliseconds) for all tests and before/after hooks in the test file. This only affects the test file from which this function is called. The default timeout interval is 5 seconds if this method is not called.

示例：

jest.setTimeout(1000); // 1 second

提示

To set timeout intervals on different tests in the same file, use the timeout option on each individual test.

If you want to set the timeout for all test files, use testTimeout configuration option.