模拟函数

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

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

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

    为了测试此函数，我们可以使用一个 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 函数也可以用于在测试期间将测试值注入代码︰

    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();
    5. // Make the mock return `true` for the first call,
    7. // and `false` for the second call
    9. filterTestFn.mockReturnValueOnce(true).mockReturnValueOnce(false);
    14. const result = [11, 12].filter(num => filterTestFn(num));
    19. console.log(result);
    21. // > [11]
    23. console.log(filterTestFn.mock.calls[0][0]); // 11
    25. console.log(filterTestFn.mock.calls[1][0]); // 12

    模拟模块

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

    users.js

    现在，为测试该方法而不实际调用 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. });

    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');
    46.   expect(bar()).toBe('bar');
    48. });

    Mock 实现

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

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

    foo.js

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

    test.js

    当你需要模拟某个函数调用返回不同结果时，请使用 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函数命名，该名字会替代 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

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