跳至主要内容
版本：29.7

Jest 对象

jest 对象在每个测试文件中都会自动处于作用域内。jest 对象中的方法有助于创建模拟，并允许你控制 Jest 的整体行为。它也可以通过 import {jest} from '@jest/globals' 显式导入。

信息

本页的 TypeScript 示例仅在你显式导入 Jest API 时才会按文档说明的那样工作

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

查阅入门指南，了解如何使用 TypeScript 设置 Jest 的详细信息。

方法​

模拟模块​

jest.disableAutomock()​

禁用模块加载器中的自动模拟。

信息

应通过 automock 配置选项启用自动模拟，才能使此方法产生任何效果。另请参阅配置选项的文档以获取更多详细信息。

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

module.exports = config;

调用 disableAutomock() 后，所有 require() 都将返回每个模块的真实版本（而不是模拟版本）。

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');
});

当您遇到的场景是您要模拟的依赖项数量远少于您不模拟的依赖项数量时，这通常很有用。例如，如果您正在为一个使用大量依赖项的模块编写测试，这些依赖项可以合理地归类为模块的“实现细节”，那么您可能不想模拟它们。

可能被视为“实现细节”的依赖项的示例包括从语言内置（例如 Array.prototype 方法）到非常常见的实用程序方法（例如 underscore、lodash、数组实用程序等）以及像 React.js 这样的整个库。

返回 jest 对象以进行链接。

提示

使用 babel-jest 时，对 disableAutomock() 的调用将自动提升到代码块的顶部。如果您想明确避免此行为，请使用 autoMockOff()。

jest.enableAutomock()​

在模块加载器中启用自动模拟。

信息

有关自动模拟的更多详细信息，请参阅 automock 配置选项的文档。

示例

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 对象以进行链接。

提示

使用 babel-jest 时，对 enableAutomock 的调用将自动提升到代码块的顶部。如果您想明确避免此行为，请使用 autoMockOn。

jest.createMockFromModule(moduleName)​

给定模块的名称，使用自动模拟系统为您生成模块的模拟版本。

当您想要创建一个扩展自动模拟行为的手动模拟时，这非常有用

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);
});

以下是 createMockFromModule 将模拟以下数据类型的方式

Function​

创建一个新的模拟函数。新函数没有正式参数，当被调用时将返回 undefined。此功能也适用于 async 函数。

Class​

创建一个新类。维护原始类的接口，所有类成员函数和属性都将被模拟。

Object​

创建一个新的深度克隆对象。维护对象键，并模拟其值。

Array​

创建一个新的空数组，忽略原始数组。

Primitives​

创建一个具有与原始属性相同基本值的新属性。

示例

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)​

当需要时，使用自动模拟版本模拟模块。factory 和 options 是可选的。例如

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.

第二个参数可用于指定一个显式模块工厂，该工厂将运行，而不是使用 Jest 的自动模拟功能

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';

当对具有默认导出的 ES6 模块使用 factory 参数时，需要指定 __esModule: true 属性。此属性通常由 Babel/TypeScript 生成，但此处需要手动设置。导入默认导出时，它是一个指令，用于从导出对象中导入名为 default 的属性

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

第三个参数可用于创建虚拟模拟——不存在于系统中任何位置的模块模拟

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},
);
注意

在设置文件中导入模块（如 setupFilesAfterEnv 所指定）将阻止对所讨论的模块以及它导入的所有模块进行模拟。

使用 jest.mock 模拟的模块仅对调用 jest.mock 的文件进行模拟。即使在模拟模块的测试文件之后运行，导入该模块的另一个文件仍将获得原始实现。

返回 jest 对象以进行链接。

提示

在 TypeScript 中编写测试？使用 jest.Mocked 实用类型或 jest.mocked() 帮助器方法为模拟的模块指定类型。

jest.Mocked<Source>​

有关文档，请参阅 Mock Functions 页面中的 TypeScript 使用 章节。

jest.mocked(source, options?)​

有关文档，请参阅 Mock Functions 页面中的 TypeScript 使用 章节。

jest.unmock(moduleName)​

指示模块系统永远不应从 require() 返回指定模块的模拟版本（例如，它应始终返回真实模块）。

此 API 最常见的用法是指定给定测试打算测试的模块（因此不希望自动模拟）。

返回 jest 对象以进行链接。

jest.deepUnmock(moduleName)​

指示模块系统永远不应返回指定模块及其依赖项的模拟版本。

返回 jest 对象以进行链接。

jest.doMock(moduleName, factory, options)​

使用 babel-jest 时，对 mock 的调用将自动提升到代码块的顶部。如果您想明确避免此行为，请使用此方法。

当您想在同一个文件中以不同的方式模拟模块时，这是一个有用的示例

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);
});

在 ES6 导入中使用 jest.doMock() 需要其他步骤。如果您不想在测试中使用 require，请遵循以下步骤

  • 我们必须指定 __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)​

使用 babel-jest 时，对 unmock 的调用将自动提升到代码块的顶部。如果您希望明确避免此行为，请使用此方法。

返回 jest 对象以进行链接。

jest.setMock(moduleName, moduleExports)​

明确提供模块系统应为指定模块返回的模拟对象。

有时，模块系统通常会自动生成模拟，但它不足以满足您的测试需求。通常情况下，您应该编写一个手动模拟，该模拟更适合于所讨论的模块。但是，在极少数情况下，即使是手动模拟也不适合您的目的，您需要在测试中自己构建模拟。

在这些罕见的情况下，您可以使用此 API 手动填充模块系统模拟模块注册表中的插槽。

返回 jest 对象以进行链接。

信息

建议使用 jest.mock()。jest.mock API 的第二个参数是模块工厂，而不是预期的导出模块对象。

jest.requireActual(moduleName)​

返回实际模块而不是模拟，绕过所有关于模块是否应该接收模拟实现的检查。

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.requireMock(moduleName)​

返回模拟模块而不是实际模块，绕过所有关于模块是否应该正常需要的检查。

jest.resetModules()​

重置模块注册表 - 所有必需模块的缓存。这对于隔离本地状态可能在测试之间冲突的模块非常有用。

示例

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

在测试中的示例

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) 比 jest.resetModules() 更进一步，为回调函数中加载的模块创建沙盒注册表。这有助于为每个测试隔离特定模块，以便本地模块状态不会在测试之间发生冲突。

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

const otherCopyOfMyModule = require('myModule');

jest.isolateModulesAsync(fn)​

jest.isolateModulesAsync() 等同于 jest.isolateModules()，但适用于异步回调。调用方应 await isolateModulesAsync 的完成。

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

const otherCopyOfMyModule = await import('myModule');

模拟函数​

jest.fn(implementation?)​

返回一个新的、未使用的 模拟函数。可以选取模拟实现。

const mockFn = jest.fn();
mockFn();
expect(mockFn).toHaveBeenCalled();

// With a mock implementation:
const returnsTrue = jest.fn(() => true);
console.log(returnsTrue()); // true;
提示

有关 TypeScript 用法的详细信息，请参阅 模拟函数 页面。

jest.isMockFunction(fn)​

确定给定函数是否为模拟函数。

jest.replaceProperty(object, propertyKey, value)​

使用 value 替换 object[propertyKey]。该属性必须已存在于该对象中。可以多次替换同一属性。返回 Jest 替换属性。

注意

要模拟定义为 getter 或 setter 的属性，请改用 jest.spyOn(object, methodName, accessType)。要模拟函数，请改用 jest.spyOn(object, methodName)。

提示

所有使用 jest.replaceProperty 替换的属性都可以通过在 afterEach 方法上调用 jest.restoreAllMocks 来还原为原始值。

示例

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

module.exports = utils;

示例测试

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)​

创建一个类似于 jest.fn 的模拟函数，但也会跟踪对 object[methodName] 的调用。返回一个 Jest 模拟函数。

注意

默认情况下，jest.spyOn 还会调用被监视的方法。这与大多数其他测试库的行为不同。如果要覆盖原始函数，可以使用 jest.spyOn(object, methodName).mockImplementation(() => customImplementation) 或 object[methodName] = jest.fn(() => customImplementation)。

提示

由于 jest.spyOn 是一个模拟，因此可以通过在传递给 afterEach 钩子的回调函数中调用 jest.restoreAllMocks 来恢复初始状态。

示例

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

module.exports = video;

示例测试

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?)​

从 Jest 22.1.0+ 开始，jest.spyOn 方法采用一个可选的第三个参数 accessType，它可以是 'get' 或 'set'，当你想分别监视 getter 或 setter 时，这将非常有用。

示例

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;

示例测试

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>​

有关文档，请参阅模拟函数页面的 TypeScript 用法 章节。

jest.Spied<Source>​

有关文档，请参阅模拟函数页面的 TypeScript 用法 章节。

jest.clearAllMocks()​

清除所有模拟的 mock.calls、mock.instances、mock.contexts 和 mock.results 属性。等同于对每个模拟函数调用 .mockClear()。

返回 jest 对象以进行链接。

jest.resetAllMocks()​

重置所有模拟的状态。等同于对每个模拟函数调用 .mockReset()。

返回 jest 对象以进行链接。

jest.restoreAllMocks()​

将所有模拟和替换的属性还原为其原始值。等同于对每个模拟函数调用 .mockRestore()，对每个替换的属性调用 .restore()。请注意，jest.restoreAllMocks() 仅适用于使用 jest.spyOn() 创建的模拟和使用 jest.replaceProperty() 替换的属性；其他模拟需要你手动还原它们。

模拟计时器​

jest.useFakeTimers(fakeTimersConfig?)​

指示 Jest 使用全局日期、性能、时间和计时器 API 的伪造版本。伪造计时器实现由 @sinonjs/fake-timers 支持。

伪造计时器将用一个从伪造时钟获取时间的实现替换 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 = {
  /**
   * If set to `true` all timers will be advanced automatically by 20 milliseconds
   * every 20 milliseconds. A custom time delta may be provided by passing a number.
   * The default is `false`.
   */
  advanceTimers?: boolean | number;
  /**
   * List of names of APIs that should not be faked. The default is `[]`, meaning
   * all APIs are faked.
   */
  doNotFake?: Array<FakeableAPI>;
  /**
   * Use the old fake timers implementation instead of one backed by `@sinonjs/fake-timers`.
   * The default is `false`.
   */
  legacyFakeTimers?: boolean;
  /** Sets current system time to be used by fake timers, in milliseconds. The default is `Date.now()`. */
  now?: number | Date;
  /**
   * The maximum number of recursive timers that will be run when calling `jest.runAllTimers()`.
   * The default is `100_000` timers.
   */
  timerLimit?: number;
};

调用 jest.useFakeTimers() 将对文件中的所有测试使用伪造计时器，直到使用 jest.useRealTimers() 恢复原始计时器。

你可以从任何地方调用 jest.useFakeTimers() 或 jest.useRealTimers()：顶层、test 块内部等。请记住，这是一个全局操作，将影响同一文件中的其他测试。在同一测试文件中再次调用 jest.useFakeTimers() 将重置内部状态（例如计时器计数），并使用提供的选项重新安装伪造计时器

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 模拟函数替换 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', () => {
  // ...
});

返回 jest 对象以进行链接。

jest.runAllTicks()​

耗尽微任务队列（通常通过 process.nextTick 在 node 中进行接口）。

当调用此 API 时，将执行通过 process.nextTick 排队的全部待处理微任务。此外，如果这些微任务本身安排了新的微任务，那么这些微任务将持续耗尽，直到队列中不再有微任务为止。

jest.runAllTimers()​

耗尽宏任务队列（即，setTimeout()、setInterval() 和 setImmediate() 排队的全部任务）和微任务队列（通常通过 process.nextTick 在节点中进行接口）。

调用此 API 时，将执行所有挂起的宏任务和微任务。如果这些任务本身计划新任务，则这些任务将持续耗尽，直至队列中不再有剩余任务。

这通常有助于在测试期间同步执行超时，以便同步断言仅在 setTimeout() 或 setInterval() 回调执行后才会发生的某些行为。有关更多信息，请参阅Timer mocks 文档。

jest.runAllTimersAsync()​

jest.runAllTimers() 的异步等效项。它允许任何计划的 Promise 回调在运行计时器之前执行。

信息

使用传统伪造计时器实现时，此函数不可用。

jest.runAllImmediates()​

耗尽由 setImmediate() 排队的全部任务。

信息

仅在使用传统伪造计时器实现时此函数才可用。

jest.advanceTimersByTime(msToRun)​

仅执行宏任务队列（即，由 setTimeout() 或 setInterval() 和 setImmediate() 排队的全部任务）。

调用此 API 时，所有计时器均提前 msToRun 毫秒。将执行所有已通过 setTimeout() 或 setInterval() 排队且将在该时间范围内执行的挂起“宏任务”。此外，如果这些宏任务计划在同一时间范围内执行的新宏任务，则将执行这些宏任务，直至队列中不再有应在 msToRun 毫秒内运行的宏任务。

jest.advanceTimersByTimeAsync(msToRun)​

jest.advanceTimersByTime(msToRun) 的异步等效项。它允许任何已计划的 Promise 回调在运行计时器之前执行。

信息

使用传统伪造计时器实现时，此函数不可用。

jest.runOnlyPendingTimers()​

仅执行当前挂起的宏任务（即，截至目前仅由 setTimeout() 或 setInterval() 排队的任务）。如果任何当前挂起的宏任务计划了新的宏任务，则此调用不会执行这些新任务。

这对于以下场景很有用：被测试的模块计划了一个 setTimeout()，其回调递归地计划了另一个 setTimeout()（这意味着计划永远不会停止）。在这些场景中，按一次步骤向前运行很有用。

jest.runOnlyPendingTimersAsync()​

jest.runOnlyPendingTimers() 的异步等效项。它允许任何已计划的 Promise 回调在运行计时器之前执行。

信息

使用传统伪造计时器实现时，此函数不可用。

jest.advanceTimersToNextTimer(steps)​

将所有计时器推进所需毫秒数，以便仅运行下一个超时/间隔。

或者，你可以提供 steps，这样它将运行 steps 数量的下一个超时/间隔。

jest.advanceTimersToNextTimerAsync(steps)​

jest.advanceTimersToNextTimer(steps) 的异步等效项。它允许任何已计划的 Promise 回调在运行计时器之前执行。

信息

使用传统伪造计时器实现时，此函数不可用。

jest.clearAllTimers()​

从计时器系统中移除任何挂起的计时器。

这意味着，如果已计划任何计时器（但尚未执行），则它们将被清除，并且将来永远没有机会执行。

jest.getTimerCount()​

返回仍需运行的假计时器数量。

jest.now()​

返回当前时钟的毫秒时间。如果使用真实计时器，或者如果模拟了 Date，则这等效于 Date.now()。在其他情况下（例如旧计时器），它可能有助于实现 Date.now()、performance.now() 等的自定义模拟。

jest.setSystemTime(now?: number | Date)​

设置假计时器使用的当前系统时间。模拟用户在程序运行时更改系统时钟。它会影响当前时间，但本身不会导致计时器触发；它们将完全按照不调用 jest.setSystemTime() 的情况触发。

信息

使用传统伪造计时器实现时，此函数不可用。

jest.getRealSystemTime()​

模拟时间时，Date.now() 也将被模拟。如果您出于某种原因需要访问真实的当前时间，则可以调用此函数。

信息

使用传统伪造计时器实现时，此函数不可用。

其他​

jest.getSeed()​

每次 Jest 运行时都会随机生成一个种子值，您可以在伪随机数生成器或其他任何地方使用它。

提示

使用 --showSeed 标志在测试报告摘要中打印种子。要手动设置种子的值，请使用 --seed=<num> CLI 参数。

jest.isEnvironmentTornDown()​

如果测试环境已关闭，则返回 true。

jest.retryTimes(numRetries, options?)​

运行失败的测试 n 次，直到它们通过或直到达到最大重试次数。

jest.retryTimes(3);

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

如果启用了 logErrorsBeforeRetry 选项，则导致测试失败的错误将记录到控制台。

jest.retryTimes(3, {logErrorsBeforeRetry: true});

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

返回 jest 对象以进行链接。

注意

jest.retryTimes() 必须在测试文件的顶层或 describe 块中声明。

信息

此功能仅适用于默认 jest-circus 运行程序。

jest.setTimeout(timeout)​

设置测试文件中所有测试和 before/after 钩子的默认超时间隔（以毫秒为单位）。这仅影响调用此函数的测试文件。如果未调用此方法，则默认超时间隔为 5 秒。

示例

jest.setTimeout(1000); // 1 second
提示

要在同一文件中对不同的测试设置超时间隔，请对每个单独的测试使用 timeout 选项。

如果你想为所有测试文件设置超时，请使用 testTimeout 配置选项。