Mock Functions

Mock functions are also known as "spies", because they let you spy on the behavior of a function that is called indirectly by some other code, rather than only testing the output. You can create a mock function with jest.fn(). If no implementation is given, the mock function will return undefined when invoked.

方法

• 参考

  mockFn.getMockName()

  Returns the mock name string set by calling mockFn.mockName(value).

  mockFn.mock.calls

  An array containing the call arguments of all calls that have been made to this mock function. Each item in the array is an array of arguments that were passed during the call.

  For example: A mock function f that has been called twice, with the arguments f('arg1', 'arg2'), and then with the arguments f('arg3', 'arg4'), would have a mock.calls array that looks like this:

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

  mockFn.mock.results

  An array containing the results of all calls that have been made to this mock function. Each entry in this array is an object containing a type property, and a value property. type will be one of the following:

  • 'return' - Indicates that the call completed by returning normally.
  • 'throw' - Indicates that the call completed by throwing a value.
  • 'incomplete' - Indicates that the call has not yet completed. This occurs if you test the result from within the mock function itself, or from within a function that was called by the mock.

  The value property contains the value that was thrown or returned. value is undefined when type === 'incomplete'.

  For example: A mock function f that has been called three times, returning 'result1', throwing an error, and then returning 'result2', would have a mock.results array that looks like this:

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

  mockFn.mock.instances

  An array that contains all the object instances that have been instantiated from this mock function using new.

  For example: A mock function that has been instantiated twice would have the following mock.instances array:

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

  Resets all information stored in the mockFn.mockReset()

  Does everything that mockFn.mockRestore()

  Does everything that mockFn.mockImplementation(fn)

  Accepts a function that should be used as the implementation of the mock. The mock itself will still record all calls that go into and instances that come from itself – the only difference is that the implementation will also be executed when the mock is called.

  Note: jest.fn(implementation) is a shorthand for 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 can also be used to mock class constructors:

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

  Accepts a function that will be used as an implementation of the mock for one call to the mocked function. Can be chained so that multiple function calls produce different results.

  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
  

  When the mocked function runs out of implementations defined with mockImplementationOnce, it will execute the default implementation set with jest.fn(() => defaultValue) or .mockImplementation(() => defaultValue) if they were called:

  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)

  Accepts a string to use in test result output in place of "jest.fn()" to indicate which mock function is being referenced.

  例如：

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

  Will result in this error:

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

  mockFn.mockReturnThis()

  Syntactic sugar function for:

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

  mockFn.mockReturnValue(value)

  Accepts a value that will be returned whenever the mock function is called.

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

  mockFn.mockReturnValueOnce(value)

  Accepts a value that will be returned for one call to the mock function. Can be chained so that successive calls to the mock function return different values. When there are no more mockReturnValueOnce values to use, calls will return a value specified by 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)

  Syntactic sugar function for:

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

  Useful to mock async functions in async tests:

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

  mockFn.mockResolvedValueOnce(value)

  Syntactic sugar function for:

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

  Useful to resolve different values over multiple async calls:

  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)

  Syntactic sugar function for:

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

  Useful to create async mock functions that will always reject:

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

  mockFn.mockRejectedValueOnce(value)

  Syntactic sugar function for:

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

  Example usage:

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