Version: 27.1

模拟函数

Mock 函数允许你测试代码之间的连接——实现方式包括：擦除函数的实际实现、捕获对函数的调用 ( 以及在这些调用中传递的参数) 、在使用 new 实例化时捕获构造函数的实例、允许测试时配置返回值。

有两种方法可以模拟函数：要么在测试代码中创建一个 mock 函数，要么编写一个手动 mock来覆盖模块依赖。

使用 mock 函数

假设我们要测试函数 forEach 的内部实现，这个函数为传入的数组中的每个元素调用一次回调函数。

  1. function forEach(items, callback) {
  3.   for (let index = 0; index < items.length; index++) {
  5.     callback(items[index]);
  7.   }
  9. }

为了测试此函数，我们可以使用一个 mock 函数，然后检查 mock 函数的状态来确保回调函数如期调用。

  1. const mockCallback = jest.fn(x => 42 + x);
  3. forEach([0, 1], mockCallback);
  8. // 此 mock 函数被调用了两次
  10. expect(mockCallback.mock.calls.length).toBe(2);
  15. // 第一次调用函数时的第一个参数是 0
  17. expect(mockCallback.mock.calls[0][0]).toBe(0);
  22. // 第二次调用函数时的第一个参数是 1
  24. expect(mockCallback.mock.calls[1][0]).toBe(1);
  29. // 第一次函数调用的返回值是 42
  31. expect(mockCallback.mock.results[0].value).toBe(42);

.mock 属性

所有的 mock 函数都有这个特殊的 .mock属性，它保存了关于此函数如何被调用、调用时的返回值的信息。 .mock 属性还追踪每次调用时 this的值，所以我们同样可以也检视（inspect） this：

  1. const myMock = jest.fn();
  6. const a = new myMock();
  8. const b = {};
  10. const bound = myMock.bind(b);
  12. bound();
  17. console.log(myMock.mock.instances);
  19. // > [ <a>, <b> ]

这些 mock 成员变量在测试中非常有用，用于说明这些 function 是如何被调用、实例化或返回的：

  1. // 这个函数只调用一次
  3. expect(someMockFunction.mock.calls.length).toBe(1);
  8. // 这个函数被第一次调用时的第一个 arg 是 'first arg'
  10. expect(someMockFunction.mock.calls[0][0]).toBe('first arg');
  15. // 这个函数被第一次调用时的第二个 arg 是 'second arg'
  17. expect(someMockFunction.mock.calls[0][1]).toBe('second arg');
  22. // 这个函数被实例化两次
  24. expect(someMockFunction.mock.instances.length).toBe(2);
  29. // 这个函数被第一次实例化返回的对象中，有一个 name 属性，且被设置为了 'test’ 
  31. expect(someMockFunction.mock.instances[0].name).toEqual('test');

Mock 的返回值

Mock 函数也可以用于在测试期间将测试值注入代码︰

  1. const myMock = jest.fn();
  3. console.log(myMock());
  5. // > undefined
  10. myMock.mockReturnValueOnce(10).mockReturnValueOnce('x').mockReturnValue(true);
  15. console.log(myMock(), myMock(), myMock(), myMock());
  17. // > 10, 'x', true, true

在函数连续传递风格（functional continuation-passing style）的代码中时，Mock 函数也非常有效。 以这种代码风格有助于避免复杂的中间操作，便于直观表现组件的真实意图，这有利于在它们被调用之前，将值直接注入到测试中。

  1. const filterTestFn = jest.fn();
  6. // Make the mock return `true` for the first call,
  8. // and `false` for the second call
  10. filterTestFn.mockReturnValueOnce(true).mockReturnValueOnce(false);
  15. const result = [11, 12].filter(num => filterTestFn(num));
  20. console.log(result);
  22. // > [11]
  24. console.log(filterTestFn.mock.calls[0][0]); // 11
  26. console.log(filterTestFn.mock.calls[1][0]); // 12

大多数现实世界例子中，实际是在依赖的组件上配一个模拟函数并配置它，但手法是相同的。 在这些情况下，尽量避免在非真正想要进行测试的任何函数内实现逻辑。

模拟模块

假定有个从 API 获取用户的类。 该类用 axios 调用 API 然后返回 data，其中包含所有用户的属性：

users.js

  1. import axios from 'axios';
  6. class Users {
  8.   static all() {
  10.     return axios.get('/users.json').then(resp => resp.data);
  12.   }
  14. }
  19. export default Users;

现在，为测试该方法而不实际调用 API (使测试缓慢与脆弱)，我们可以用 jest.mock(...) 函数自动模拟 axios 模块。

一旦模拟模块，我们可为 .get 提供一个 mockResolvedValue ，它会返回假数据用于测试。 In effect, we are saying that we want axios.get('/users.json') to return a fake response.

users.test.js

  1. import axios from 'axios';
  3. import Users from './users';
  8. jest.mock('axios');
  13. test('should fetch users', () => {
  15.   const users = [{name: 'Bob'}];
  17.   const resp = {data: users};
  19.   axios.get.mockResolvedValue(resp);
  24.   // or you could use the following depending on your use case:
  26.   // axios.get.mockImplementation(() => Promise.resolve(resp))
  31.   return Users.all().then(data => expect(data).toEqual(users));
  33. });

Mocking Partials

Subsets of a module can be mocked and the rest of the module can keep their actual implementation:

foo-bar-baz.js

  1. export const foo = 'foo';
  3. export const bar = () => 'bar';
  5. export default () => 'baz';
  1. //test.js
  3. import defaultExport, {bar, foo} from '../foo-bar-baz';
  8. jest.mock('../foo-bar-baz', () => {
  10.   const originalModule = jest.requireActual('../foo-bar-baz');
  15.   //Mock the default export and named export 'foo'
  17.   return {
  19.     __esModule: true,
  21.     ...originalModule,
  23.     default: jest.fn(() => 'mocked baz'),
  25.     foo: 'mocked foo',
  27.   };
  29. });
  34. test('should do a partial mock', () => {
  36.   const defaultExportResult = defaultExport();
  38.   expect(defaultExportResult).toBe('mocked baz');
  40.   expect(defaultExport).toHaveBeenCalled();
  45.   expect(foo).toBe('mocked foo');
  47.   expect(bar()).toBe('bar');
  49. });

Mock 实现

还有，在某些情况下用Mock函数替换指定返回值是非常有用的。 可以用 jest.fn 或 mockImplementationOnce方法来实现Mock函数。

  1. const myMockFn = jest.fn(cb => cb(null, true));
  6. myMockFn((err, val) => console.log(val));
  8. // > true

当你需要根据别的模块定义默认的Mock函数实现时，mockImplementation 方法是非常有用的。

foo.js

  1. module.exports = function () {
  3.   // some implementation;
  5. };

test.js

  1. jest.mock('../foo'); // this happens automatically with automocking
  3. const foo = require('../foo');
  8. // foo is a mock function
  10. foo.mockImplementation(() => 42);
  12. foo();
  14. // > 42

当你需要模拟某个函数调用返回不同结果时，请使用 mockImplementationOnce 方法︰

  1. const myMockFn = jest
  3.   .fn()
  5.   .mockImplementationOnce(cb => cb(null, true))
  7.   .mockImplementationOnce(cb => cb(null, false));
  12. myMockFn((err, val) => console.log(val));
  14. // > true
  19. myMockFn((err, val) => console.log(val));
  21. // > false

当 mockImplementationOne定义的实现逐个调用完毕时， 如果定义了jest.fn ，它将使用 jest.fn 。

  1. const myMockFn = jest
  3.   .fn(() => 'default')
  5.   .mockImplementationOnce(() => 'first call')
  7.   .mockImplementationOnce(() => 'second call');
  12. console.log(myMockFn(), myMockFn(), myMockFn(), myMockFn());
  14. // > 'first call', 'second call', 'default', 'default'

大多数情况下，我们的函数调用都是链式的，如果你希望创建的函数支持链式调用（因为返回了this），可以使用.mockReturnThis() 函数来支持。

  1. const myObj = {
  3.   myMethod: jest.fn().mockReturnThis(),
  5. };
  10. // is the same as
  15. const otherObj = {
  17.   myMethod: jest.fn(function () {
  19.     return this;
  21.   }),
  23. };

Mock 名称

你可以为你的Mock函数命名，该名字会替代 jest.fn() 在单元测试的错误输出中出现。 用这个方法你就可以在单元测试输出日志中快速找到你定义的Mock函数。

  1. const myMockFn = jest
  3.   .fn()
  5.   .mockReturnValue('default')
  7.   .mockImplementation(scalar => 42 + scalar)
  9.   .mockName('add42');

自定义匹配器

最后，测试Mock函数需要写大量的断言，为了减少代码量，我们提供了一些自定义匹配器。

  1. // The mock function was called at least once
  3. expect(mockFunc).toHaveBeenCalled();
  8. // The mock function was called at least once with the specified args
  10. expect(mockFunc).toHaveBeenCalledWith(arg1, arg2);
  15. // The last call to the mock function was called with the specified args
  17. expect(mockFunc).toHaveBeenLastCalledWith(arg1, arg2);
  22. // All calls and the name of the mock is written as a snapshot
  24. expect(mockFunc).toMatchSnapshot();

这些匹配器是断言Mock函数的语法糖。 你可以根据自己的需要自行选择匹配器。

  1. // The mock function was called at least once
  3. expect(mockFunc.mock.calls.length).toBeGreaterThan(0);
  8. // The mock function was called at least once with the specified args
  10. expect(mockFunc.mock.calls).toContainEqual([arg1, arg2]);
  15. // The last call to the mock function was called with the specified args
  17. expect(mockFunc.mock.calls[mockFunc.mock.calls.length - 1]).toEqual([
  19.   arg1,
  21.   arg2,
  23. ]);
  28. // The first arg of the last call to the mock function was `42`
  30. // (note that there is no sugar helper for this specific of an assertion)
  32. expect(mockFunc.mock.calls[mockFunc.mock.calls.length - 1][0]).toBe(42);
  37. // A snapshot will check that a mock was invoked the same number of times,
  39. // in the same order, with the same arguments. 它还会在名称上断言。 它还会在名称上断言。
  41. expect(mockFunc.mock.calls).toEqual([[arg1, arg2]]);
  43. expect(mockFunc.getMockName()).toBe('a mock name');

匹配器的完整列表，请查阅 参考文档。