閱讀(2.5k) 書簽贊(0) 我要糾錯

Jest 對象API

2021-09-23 20:23 更新

該jest對象自動在每個測試文件的范圍內。jest對象中的方法有助于創(chuàng)建模擬并讓你控制 Jest 的整體行為。它也可以通過 via 顯式導入?import {jest} from '@jest/globals?'。

模擬模塊

jest.disableAutomock()

在模塊加載器中禁用自動模擬。

有關更多信息，請參閱配置automock部分

調用此方法后，所有require()s 將返回每個模塊的真實版本（而不是模擬版本）。

有配置：

{
  "automock": true
}

示例：

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

當你要模擬的依賴項數(shù)量遠小于你不模擬的依賴項數(shù)量時，這通常很有用。例如，如果你正在為使用大量依賴項的模塊編寫測試，這些依賴項可以合理地歸類為模塊的“實現(xiàn)細節(jié)”，那么你可能不想模擬它們。

可能被視為“實現(xiàn)細節(jié)”的依賴項示例包括從語言內置（例如 ?Array.prototype? 方法）到高度通用的實用程序方法（例如下劃線?/lo-dash?、數(shù)組實用程序等）和整個庫（如 ?React?）。 ?js?。

返回jest用于鏈接的對象。

注意：此方法以前稱為?autoMockOff.? 使用時?babel-jest?，對?disableAutomock?的調用會自動提升到代碼塊的頂部。使用?autoMockOff?，如果你想明確地避免這種行為。

jest.enableAutomock()

在模塊加載器中啟用自動模擬。

返回jest用于鏈接的對象。

有關更多信息，請參閱配置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();
});

注意：此方法以前稱為?autoMockOn?. 使用時?babel-jest?，對的調用?enableAutomock?會自動提升到代碼塊的頂部。使用?autoMockOn?，如果你想明確地避免這種行為。

jest.createMockFromModule(moduleName)

在 Is 26.0.0+ 中重命名

同樣在別名下： ?.genMockFromModule(moduleName)?

給定模塊的名稱，使用自動模擬系統(tǒng)為你生成模塊的模擬版本。

當你想要創(chuàng)建擴展自動模擬行為的手動模擬時，這很有用。

示例：

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

// __tests__/createMockFromModule.test.js
const utils = jest.createMockFromModule('../utils').default;
utils.isAuthorized = jest.fn(secret => secret === 'not wizard');
test('implementation created by jest.createMockFromModule', () => {
  expect(utils.authorize.mock).toBeTruthy();
  expect(utils.isAuthorized('not wizard')).toEqual(true);
});

這是?createMockFromModule?模擬以下數(shù)據(jù)類型的方式：

函數(shù) Function

創(chuàng)建一個新的模擬函數(shù)。新函數(shù)沒有形式參數(shù)，調用時將返回?undefined?。此功能也適用于?async?函數(shù)。

類 Class

創(chuàng)建一個新類。原始類的接口被保留，所有的類成員函數(shù)和屬性都將被模擬。

對象 Object

創(chuàng)建一個新的深度克隆對象。對象鍵被維護并且它們的值被模擬。

數(shù)組 Array

創(chuàng)建一個新的空數(shù)組，忽略原始數(shù)組。

屬性 Primitives

創(chuàng)建一個與原始屬性具有相同原始值的新屬性。

示例：

// 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).toEqual('square');
  expect(example.function.length).toEqual(0);
  // async functions get the same treatment as standard synchronous functions.
  expect(example.asyncFunction.name).toEqual('asyncSquare');
  expect(example.asyncFunction.length).toEqual(0);
  // creates a new class with the same interface, member functions and properties are mocked.
  expect(example.class.constructor.name).toEqual('Bar');
  expect(example.class.foo.name).toEqual('foo');
  expect(example.class.array.length).toEqual(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.length).toEqual(0);
  // creates a new property with the same primitive value as the original property.
  expect(example.number).toEqual(123);
  expect(example.string).toEqual('baz');
  expect(example.boolean).toEqual(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.

第二個參數(shù)可用于指定正在運行的顯式模塊工廠，而不是使用 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';

將?factory?參數(shù)用于具有默認導出的 ES6 模塊時，?__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

第三個參數(shù)可用于創(chuàng)建虛擬模擬——系統(tǒng)中不存在的模塊的模擬：

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

警告：在安裝文件（由指定?setupTestFrameworkScriptFile?）中導入模塊將阻止對相關模塊及其導入的所有模塊進行模擬。

被模擬的模塊jest.mock僅針對調用jest.mock. 另一個導入模塊的文件將獲得原始實現(xiàn)，即使它在模擬模塊的測試文件之后運行。

返回jest用于鏈接的對象。

jest.unmock(moduleName)

指示模塊系統(tǒng)不應返回指定模塊的模擬版本?require()?（例如，它應始終返回真實模塊）。

此 API 最常見的用途是指定給定測試打算測試的模塊（因此不想自動模擬）。

返回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()).toEqual(1);
});
test('moduleName 2', () => {
  jest.doMock('../moduleName', () => {
    return jest.fn(() => 2);
  });
  const moduleName = require('../moduleName');
  expect(moduleName()).toEqual(2);
});

?jest.doMock()?與 ES6 導入一起使用需要額外的步驟。如果你不想?require?在測試中使用，請遵循以下步驟：

我們必須指定?__esModule: true屬性?（jest.mock()有關更多信息，請參閱API）。
靜態(tài) ES6 模塊導入被提升到文件的頂部，因此我們必須使用import().
最后，我們需要一個支持動態(tài)導入的環(huán)境。請參閱使用 Babel進行初始設置。然后將插件babel-plugin-dynamic-import-node或等效插件添加到你的 Babel 配置中以啟用 Node.js 中的動態(tài)導入。

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

返回jest用于鏈接的對象。

jest.dontMock(moduleName)

使用時?babel-jest?，對的調用?unmock?會自動提升到代碼塊的頂部。如果你想明確避免這種行為，請使用此方法。

返回jest用于鏈接的對象。

jest.setMock(moduleName, moduleExports)

顯式提供模塊系統(tǒng)應為指定模塊返回的模擬對象。

有時，模塊系統(tǒng)通常為你提供的自動生成的模擬有時不足以滿足你的測試需求。通常在這些情況下，你應該編寫一個更適合相關模塊的手動模擬。但是，在極少數(shù)情況下，即使是手動模擬也不適合你的目的，你需要在測試中自己構建模擬。

在這些罕見的情況下，你可以使用此 API 手動填充模塊系統(tǒng)的模擬模塊注冊表中的插槽。

返回jest用于鏈接的對象。

注意建議jest.mock()改用。該jest.mockAPI的第二個參數(shù)是一個模塊工廠，而不是預期輸出模塊對象。

jest.requireActual(moduleName)

返回實際模塊而不是模擬，繞過對模塊是否應接收模擬實現(xiàn)的所有檢查。

示例：

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().mockReturnValue(10),
  };
});
const getRandom = require('../myModule').getRandom;
getRandom(); // Always returns 10

jest.requireMock(moduleName)

返回一個模擬模塊而不是實際模塊，繞過對模塊是否應該正常需要的所有檢查。

jest.resetModules()

重置模塊注冊表 - 所有必需模塊的緩存。這對于隔離本地狀態(tài)可能在測試之間發(fā)生沖突的模塊很有用。

示例：

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()?為回調函數(shù)中加載的模塊創(chuàng)建沙箱注冊表更進一步。這對于隔離每個測試的特定模塊非常有用，這樣本地模塊狀態(tài)就不會在測試之間發(fā)生沖突。

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

模擬功能

jest.fn(implementation)

返回一個新的、未使用的模擬函數(shù)?？蛇x地采用模擬實現(xiàn)。

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

jest.isMockFunction(fn)

確定給定的函數(shù)是否是模擬函數(shù)。

jest.spyOn(object, methodName)

創(chuàng)建一個類似于?jest.fn?但也跟蹤對的調用的模擬函數(shù)?object[methodName]?。返回一個 Jest模擬函數(shù)。

注意：默認情況下，?jest.spyOn?也會調用?spied?方法。這是與大多數(shù)其他測試庫不同的行為。如果你想覆蓋原來的功能，你可以使用?jest.spyOn(object, methodName).mockImplementation(() => customImplementation)?或?object[methodName] = jest.fn(() => customImplementation);?

示例：

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

示例測試：

const video = require('./video');
test('plays video', () => {
  const spy = jest.spyOn(video, 'play');
  const isPlaying = video.play();
  expect(spy).toHaveBeenCalled();
  expect(isPlaying).toBe(true);
  spy.mockRestore();
});

jest.spyOn(object, methodName, accessType?)

從 Jest 22.1.0+ 開始，該?jest.spyOn?方法采用可選的第三個參數(shù)?accessType?，可以是?'get??或?'set'?，這在你想分別監(jiān)視 ?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 video = require('./video');
test('plays video', () => {
  const spy = jest.spyOn(video, 'play', 'get'); // we pass 'get'
  const isPlaying = video.play;
  expect(spy).toHaveBeenCalled();
  expect(isPlaying).toBe(true);
  spy.mockRestore();
});
const audio = require('./audio');
test('plays audio', () => {
  const spy = jest.spyOn(audio, 'volume', 'set'); // we pass 'set'
  audio.volume = 100;
  expect(spy).toHaveBeenCalled();
  expect(audio.volume).toBe(100);
  spy.mockRestore();
});

jest.clearAllMocks()

清除所有模擬的mock.calls和mock.instances屬性。相當于調用.mockClear()每個模擬函數(shù)。

返回jest用于鏈接的對象。

jest.resetAllMocks()

重置所有模擬的狀態(tài)。相當于調用.mockReset()每個模擬函數(shù)。

返回jest用于鏈接的對象。

jest.restoreAllMocks()

將所有模擬恢復到其原始值。相當于調用.mockRestore()每個模擬函數(shù)。請注意，jest.restoreAllMocks()只有在使用jest.spyOn;創(chuàng)建模擬時才有效；其他模擬將要求你手動恢復它們。

模擬計時器

jest.useFakeTimers(implementation?: 'modern' | 'legacy')

指示玩笑使用的標準定時器功能假版本（setTimeout，setInterval，clearTimeout，clearInterval，nextTick，setImmediate和clearImmediate）。

如果你'modern'作為參數(shù)傳遞，@sinonjs/fake-timers將用作實現(xiàn)而不是 Jest 自己的假計時器。這也模擬了額外的計時器，如Date. 'modern'將是 Jest 27 中的默認行為。

返回jest用于鏈接的對象。

jest.useRealTimers()

指示 Jest 使用標準計時器函數(shù)的真實版本。

返回jest用于鏈接的對象。

jest.runAllTicks()

廢氣的微-task隊列（通常在節(jié)點經由接口?process.nextTick?）。

調用此 API 時，所有已通過排隊的待處理微任務process.nextTick將被執(zhí)行。此外，如果這些微任務自己調度新的微任務，這些微任務將不斷耗盡，直到隊列中沒有更多的微任務。

jest.runAllTimers()

廢氣兩者宏-task隊列（即，所有的任務排隊通過setTimeout()，setInterval()和setImmediate()）和微-task隊列（通常在節(jié)點經由接口?process.nextTick?）。

調用此 API 時，將執(zhí)行所有未決的宏任務和微任務。如果這些任務自己安排了新任務，那么這些任務將不斷耗盡，直到隊列中沒有剩余任務為止。

這對于在測試期間同步執(zhí)行 setTimeouts 通常很有用，以便同步斷言某些僅在執(zhí)行?setTimeout()?或?setInterval()?回調后才會發(fā)生的行為。有關更多信息，請參閱計時器模擬文檔。

jest.runAllImmediates()

耗盡排隊的所有任務?setImmediate()?。

注意：使用現(xiàn)代偽定時器實現(xiàn)時，此功能不可用

jest.advanceTimersByTime(msToRun)

在 Is 22.0.0+ 中重命名

同樣在別名下： .runTimersToTime()

只執(zhí)行宏任務隊列（即所有由?setTimeout()orsetInterval()?和排隊的任務?setImmediate()?）。

調用此 API 時，所有計時器都會提前?msToRun?幾毫秒。所有已通過?setTimeout()?或排隊?setInterval()?并在此時間范圍內執(zhí)行的未決“宏任務”都將被執(zhí)行。此外，如果這些宏任務調度將在同一時間范圍內執(zhí)行的新宏任務，則這些宏任務將被執(zhí)行，直到隊列中沒有更多宏任務剩余，這應該在?msToRun?幾毫秒內運行。

jest.runOnlyPendingTimers()

僅執(zhí)行當前掛起的宏任務（即，僅執(zhí)行已排隊?setTimeout()?或?setInterval()?到此為止的任務）。如果任何當前掛起的宏任務調度新的宏任務，則該調用將不會執(zhí)行這些新任務。

這對于諸如被測試模塊調度 ?asetTimeout()?其回調以?setTimeout()?遞歸方式調度另一個（意味著調度永不停止）的場景很有用。在這些情況下，能夠一次一步向前運行是很有用的。

jest.advanceTimersToNextTimer(steps)

將所有計時器提前所需的毫秒數(shù)，以便僅運行下一個超時/間隔。

或者，你可以提供steps，因此它將運行steps下一次超時/間隔的數(shù)量。

jest.clearAllTimers()

從計時器系統(tǒng)中刪除任何掛起的計時器。

這意味著，如果任何計時器已被調度（但尚未執(zhí)行），它們將被清除并且將來永遠沒有機會執(zhí)行。

jest.getTimerCount()

返回仍要運行的假計時器的數(shù)量。

jest.setSystemTime(now?: number | Date)

設置假定時器使用的當前系統(tǒng)時間。模擬用戶在程序運行時更改系統(tǒng)時鐘。它會影響當前時間，但它本身不會導致例如定時器觸發(fā)；他們將完全按照沒有調用?jest.setSystemTime()?.

注意：此功能僅在使用現(xiàn)代偽計時器實現(xiàn)時可用

jest.getRealSystemTime()

當?mocking?的時候，??Date.now()??也會被?mock? 。如果你出于某種原因需要訪問實時當前時間，你可以調用此函數(shù)。

注意：此功能僅在使用現(xiàn)代偽計時器實現(xiàn)時可用

雜項

jest.setTimeout(timeout)

以毫秒為單位設置測試和掛鉤之前/之后的默認超時間隔。這僅影響調用此函數(shù)的測試文件。

注意：如果不調用此方法，默認超時間隔為 5 秒。

注意：如果你想為所有測試文件設置超時，一個很好的地方是在?setupFilesAfterEnv?.

示例：

jest.setTimeout(1000); // 1 second

jest.retryTimes()

運行失敗的測試 n 次，直到它們通過或直到用盡最大重試次數(shù)。這只適用于jest-circus！

測試中的示例：

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

返回jest用于鏈接的對象。

以上內容是否對您有幫助：

← Jest 模擬函數(shù)API

Jest 配置 →

寫筆記

我要補充