23.x

Edit

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. Puteți crea o funcţie mock cu jest.fn(). În cazul în care nu este specificată o implementare, funcţia mock va returna undefined când este apelată.

Metode

Referințe

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 boolean isThrow property, and a value property. isThrow is true if the call terminated due to a throw, or false if the call returned normally. The value property contains the value that was thrown or returned.

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:

[
  {
    isThrow: false,
    value: 'result1',
  },
  {
    isThrow: true,
    value: {
      /* Error instance */
    },
  },
  {
    isThrow: false,
    value: 'result2',
  },
];

mockFn.mock.instances

Un array care conţine toate instanţele obiectelor instanţiate din această funcţie mock, folosind new.

De exemplu: O funcţie mock, care a fost instanţiată de două ori ar avea array-ul mock.instances următor:

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

Resetează toate informaţiile stocate în array-urile mockFn.mock.calls şi mockFn.mock.instances.

Acest lucru este util atunci când doriţi să curăţați datele unui mock între două aserțiuni.

Țineți cont că mockClear va înlocui mockFn.mock, nu doar mockFn.mock.calls şi mockFn.mock.instances. You should, therefore, avoid assigning mockFn.mock to other variables, temporary or not, to make sure you don't access stale data.

Opţiunea de configurare clearMocks este disponibilă pentru a curăța automat mock-urile între teste.

mockFn.mockReset()

Does everything that mockFn.mockClear() does, and also removes any mocked return values or implementations.

This is useful when you want to completely reset a mock back to its initial state. (Note that resetting a spy will result in a function with no return value).

Țineți cont că mockReset va înlocui mockFn.mock, nu doar mockFn.mock.calls şi mockFn.mock.instances. You should, therefore, avoid assigning mockFn.mock to other variables, temporary or not, to make sure you don't access stale data.

mockFn.mockRestore()

Does everything that mockFn.mockReset() does, and also restores the original (non-mocked) implementation.

Acest lucru este util atunci când vreți să dublați funcţii în anumite cazuri de testare şi să restabiliți implementarea originală în altele.

Beware that mockFn.mockRestore only works when the mock was created with jest.spyOn. Așadar trebuie să faceți voi curățarea atunci când folosiți jest.fn().

The restoreMocks configuration option is available to restore mocks automatically between tests.

mockFn.mockImplementation(fn)

Acceptă o funcţie care va fi folosită ca implementare a mock-ului. Mock în sine va înregistra în continuare toate apelurile și instanțierile – singura diferenţă este că implementarea va fi executată și ea când este apelat mock-ul.

Notă: jest.fn(implementare) este o prescurtare pentru jest.fn().mockImplementation(implementare).

De exemplu:

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 poate fi folosit și pentru dublarea constructorilor de clase:

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

Atunci când funcţia mock rămâne fără implementări definite cu mockImplementationOnce, se va executa implementarea implicită cu jest.fn(() = > valoare-implicită) sau .mockImplementation(() = > valoare-implicită) dacă acestea au fost definite:

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.

De exemplu:

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)

Acceptă o valoare ce va fi returnată ori de câte ori se apelează funcţia mock.

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

mockFn.mockReturnValueOnce(value)

Acceptă o valoare ce va fi returnată pentru un singur apel al funcţiei mock. Poate fi înlănțuită astfel încât apeluri succesive ale funcţiei mock vor returna valori diferite. Atunci când nu mai există valori mockReturnValueOnce rămase, apelurile următoare vor returna valoarea specificată de 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"
});
← ExpectThe Jest Object →