Jest 模擬函數(shù)API

模擬函數(shù)也被稱為“間諜”，因為它們讓你可以監(jiān)視由其他代碼間接調(diào)用的函數(shù)的行為，而不僅僅是測試輸出。你可以使用?jest.fn()?. 如果沒有給出實現(xiàn)，模擬函數(shù)將?undefined?在調(diào)用時返回。

方法

• mockFn.getMockName()
• mockFn.mock.calls
• mockFn.mock.results
• mockFn.mock.instances
• mockFn.mockClear()
• mockFn.mockReset()
• mockFn.mockRestore()
• mockFn.mockImplementation(fn)
• mockFn.mockImplementationOnce(fn)
• mockFn.mockName(value)
• mockFn.mockReturnThis()
• mockFn.mockReturnValue(value)
• mockFn.mockReturnValueOnce(value)
• mockFn.mockResolvedValue(value)
• mockFn.mockResolvedValueOnce(value)
• mockFn.mockRejectedValue(value)
• mockFn.mockRejectedValueOnce(value)

參考

mockFn.getMockName()

返回通過調(diào)用設(shè)置的模擬名稱字符串?mockFn.mockName(value)?。

mockFn.mock.calls

包含對此模擬函數(shù)進(jìn)行的所有調(diào)用的調(diào)用參數(shù)的數(shù)組。數(shù)組中的每一項都是調(diào)用期間傳遞的參數(shù)數(shù)組。

例如：一個模擬函數(shù)f被調(diào)用了兩次，使用參數(shù)?f('arg1', 'arg2')?，然后使用參數(shù)?f('arg3', 'arg4')?，將有一個如下所示的?mock.calls?數(shù)組：

[
  ['arg1', 'arg2'],
  ['arg3', 'arg4'],
];

mockFn.mock.results

一個數(shù)組，包含對此模擬函數(shù)進(jìn)行的所有調(diào)用的結(jié)果。此數(shù)組中的每個條目都是一個包含?type?屬性和?value?屬性的對象。?type?將是以下之一：

• ?'return'? - 表示呼叫通過正常返回完成。
• ?'throw'? - 表示通過拋出一個值來完成調(diào)用。
• ?'incomplete'?- 表示呼叫尚未完成。如果你從模擬函數(shù)本身或從模擬調(diào)用的函數(shù)中測試結(jié)果，則會發(fā)生這種情況。

value?屬性包含拋出或返回的值。?當(dāng)?type === 'incomplete'時，value?未定義?。

例如：一個模擬函數(shù)?f?被調(diào)用了 3 次，返回?'result1'?，拋出錯誤，然后返回?'result2'?，將有一個如下所示的?mock.results?數(shù)組：

[
  {
    type: 'return',
    value: 'result1',
  },
  {
    type: 'throw',
    value: {
      /* Error instance */
    },
  },
  {
    type: 'return',
    value: 'result2',
  },
];

mockFn.mock.instances

一個數(shù)組，其中包含已使用此模擬函數(shù)實例化的所有對象實例?new?。

例如：已實例化兩次的模擬函數(shù)將具有以下?mock.instances?數(shù)組：

const mockFn = jest.fn();
const a = new mockFn();
const b = new mockFn();
mockFn.mock.instances[0] === a; // true
mockFn.mock.instances[1] === b; // true

mockFn.mockClear()

重置存儲在mockFn.mock.calls和mockFn.mock.instances數(shù)組中的所有信息。

當(dāng)你想要清理兩個斷言之間的模擬使用數(shù)據(jù)時，這通常很有用。

當(dāng)心，mockClear將取代mockFn.mock，而不僅僅是mockFn.mock.calls和mockFn.mock.instances。因此，你應(yīng)該避免分配?mockFn.mock?給其他變量，無論是臨時的還是非臨時的，以確保你不會訪問過時的數(shù)據(jù)。

clearMocks配置選項可用于在測試之間自動清除模擬。

mockFn.mockReset()

執(zhí)行所有mockFn.mockClear()操作，并刪除任何模擬的返回值或?qū)崿F(xiàn)。

當(dāng)你想要完全重置 mock 到初始狀態(tài)時，這是有用。 (注意重置一個 spy 將導(dǎo)致一個沒有返回值的函數(shù))。

當(dāng)心，?mockReset?將取代?mockFn.mock?，而不僅僅是mockFn.mock.calls和mockFn.mock.instances。因此，你該避免分配?mockFn.mock?給其他變量，無論是臨時的還是非臨時的，以確保你不會訪問過時的數(shù)據(jù)。

mockFn.mockRestore()

執(zhí)行所有mockFn.mockReset()操作，并恢復(fù)原始（非模擬）實現(xiàn)。

當(dāng)你想在某些測試用例中模擬函數(shù)并在其他測試用例中恢復(fù)原始實現(xiàn)時，這很有用。

請注意，?mockFn.mockRestore?只有在使用?jest.spyOn?. 因此，你必須在手動分配?jest.fn()?.

restoreMocks配置選項可用于在測試之間自動恢復(fù)模擬。

mockFn.mockImplementation(fn)

接受一個應(yīng)該用作模擬實現(xiàn)的函數(shù)。模擬本身仍然會記錄進(jìn)入的所有調(diào)用和來自自身的實例——唯一的區(qū)別是當(dāng)模擬被調(diào)用時，實現(xiàn)也會被執(zhí)行。

注意：?jest.fn(implementation)?是 的簡寫?jest.fn().mockImplementation(implementation)?。

例如：

const mockFn = jest.fn().mockImplementation(scalar => 42 + scalar);
// or: jest.fn(scalar => 42 + scalar);
const a = mockFn(0);
const b = mockFn(1);
a === 42; // true
b === 43; // true
mockFn.mock.calls[0][0] === 0; // true
mockFn.mock.calls[1][0] === 1; // true

?mockImplementation ?也可用于模擬類構(gòu)造函數(shù)：

// SomeClass.js
module.exports = class SomeClass {
  m(a, b) {}
};
// OtherModule.test.js
jest.mock('./SomeClass'); // this happens automatically with automocking
const SomeClass = require('./SomeClass');
const mMock = jest.fn();
SomeClass.mockImplementation(() => {
  return {
    m: mMock,
  };
});
const some = new SomeClass();
some.m('a', 'b');
console.log('Calls to m: ', mMock.mock.calls);

mockFn.mockImplementationOnce(fn)

接受一個函數(shù)，該函數(shù)將用作對模擬函數(shù)的一次調(diào)用的模擬實現(xiàn)?？梢枣溄?，以便多個函數(shù)調(diào)用產(chǎn)生不同的結(jié)果。

const myMockFn = jest
  .fn()
  .mockImplementationOnce(cb => cb(null, true))
  .mockImplementationOnce(cb => cb(null, false));
myMockFn((err, val) => console.log(val)); // true
myMockFn((err, val) => console.log(val)); // false

當(dāng)模擬函數(shù)用完用 ?mockImplementationOnce ?定義的實現(xiàn)時，它將執(zhí)行設(shè)置的默認(rèn)實現(xiàn)，?jest.fn(() => defaultValue)?或者?.mockImplementation(() => defaultValue)?如果它們被調(diào)用：

const myMockFn = jest
  .fn(() => 'default')
  .mockImplementationOnce(() => 'first call')
  .mockImplementationOnce(() => 'second call');
// 'first call', 'second call', 'default', 'default'
console.log(myMockFn(), myMockFn(), myMockFn(), myMockFn());

mockFn.mockName(value)

接受在測試結(jié)果輸出中使用的字符串代替?“jest.fn()”?以指示正在引用哪個模擬函數(shù)。

例如：

const mockFn = jest.fn().mockName('mockedFunction');
// mockFn();
expect(mockFn).toHaveBeenCalled();

會導(dǎo)致這個錯誤：

expect(mockedFunction).toHaveBeenCalled()
Expected mock function "mockedFunction" to have been called, but it was not called.

mockFn.mockReturnThis()

語法糖函數(shù)用于：

jest.fn(function () {
  return this;
});

mockFn.mockReturnValue(value)

接受一個將在調(diào)用模擬函數(shù)時返回的值。

const mock = jest.fn();
mock.mockReturnValue(42);
mock(); // 42
mock.mockReturnValue(43);
mock(); // 43

mockFn.mockReturnValueOnce(value)

接受將在一次調(diào)用模擬函數(shù)時返回的值?？梢枣溄樱员銓δM函數(shù)的連續(xù)調(diào)用返回不同的值。當(dāng)沒有更多?mockReturnValueOnce?值可以使用時，調(diào)用將返回一個由 指定的值?mockReturnValue?。

const myMockFn = jest
  .fn()
  .mockReturnValue('default')
  .mockReturnValueOnce('first call')
  .mockReturnValueOnce('second call');
// 'first call', 'second call', 'default', 'default'
console.log(myMockFn(), myMockFn(), myMockFn(), myMockFn());

mockFn.mockResolvedValue(value)

語法糖函數(shù)用于：

jest.fn().mockImplementation(() => Promise.resolve(value));

在異步測試中模擬異步函數(shù)很有用：

test('async test', async () => {
  const asyncMock = jest.fn().mockResolvedValue(43);
  await asyncMock(); // 43
});

mockFn.mockResolvedValueOnce(value)

語法糖函數(shù)用于：

jest.fn().mockImplementationOnce(() => Promise.resolve(value));

用于解決多個異步調(diào)用的不同值：

test('async test', async () => {
  const asyncMock = jest
    .fn()
    .mockResolvedValue('default')
    .mockResolvedValueOnce('first call')
    .mockResolvedValueOnce('second call');
  await asyncMock(); // first call
  await asyncMock(); // second call
  await asyncMock(); // default
  await asyncMock(); // default
});

mockFn.mockRejectedValue(value)

語法糖函數(shù)用于：

jest.fn().mockImplementation(() => Promise.reject(value));

用于創(chuàng)建始終拒絕的異步模擬函數(shù)：

test('async test', async () => {
  const asyncMock = jest.fn().mockRejectedValue(new Error('Async error'));
  await asyncMock(); // throws "Async error"
});

mockFn.mockRejectedValueOnce(value)

語法糖函數(shù)用于：

jest.fn().mockImplementationOnce(() => Promise.reject(value));

用法示例：

test('async test', async () => {
  const asyncMock = jest
    .fn()
    .mockResolvedValueOnce('first call')
    .mockRejectedValueOnce(new Error('Async error'));
  await asyncMock(); // first call
  await asyncMock(); // throws "Async error"
});