Mock Functions

Funciones Mockeadas también son conocidos como "espías", porque permiten espiar el comportamiento de una función que se llama indirectamente por algunos otros códigos, en lugar de sólo la salida de la prueba. Puedes crear una falsa función con jest.fn(). Si no se da la implementación, la función mockeda devolverá undefined cuando se invoque.

Métodos #

Referencia #

mockFn.mock.calls #

Una matriz que representa todas las llamadas que se hicieron en esta función mockeada. Cada llamada está representada por una serie de argumentos que se pasan durante la llamada.

Por ejemplo: una función de mocking f que se ha llamado dos veces, con los argumentos f ('arg1', 'arg2'), y luego con los argumentos f ('arg3', 'arg4') tendría una matriz de mock.calls que se ve así:

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

mockFn.mock.instances #

Una matriz que contiene todas las instancias de objeto que han se han creado instancias de esta función mockeada utilizando new.

Por ejemplo: una función mockeada que ha creado una instancia dos veces, tendría la siguiente matriz de mock.instances:

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

Restablece toda la información almacenada en las matrices mockFn.mock.calls y mockFn.mock.instances.

A menudo esto es útil cuando quieres limpiar datos de uso de mocking entre dos afirmaciones.

Cuidado con ese mockClear reemplazará a mockFn.mock, no mockFn.mock.calls y mockFn.mock.instances. Por lo tanto debes evitar asignar mockFn.mock a otras variables, temporales o no, para asegurarse de que no tienes acceso a datos antiguos.

The clearMocks configuration option is available to clear mocks automatically between tests.

mockFn.mockReset() #

Restablece toda la información almacenada en el mock, incluida cualquier implementación inicial dada.

Esto es útil cuando deseas restaurar completamente un mock a su estado inicial.

Cuidado con ese mockClear reemplazará a mockFn.mock, no mockFn.mock.calls y mockFn.mock.instances. Por lo tanto debes evitar asignar mockFn.mock a otras variables, temporales o no, para asegurarse de que no tienes acceso a datos antiguos.

mockFn.mockRestore() #

Remueve el mock y restablece la implementación inicial.

Esto es útil para casos donde se desee simular funciones en ciertas pruebas y restaurar la implementación original para otras.

Se debe tener cuidado que mockFn.mockRestore sólo funcionara para mocks creados con jest.spyOn. De modo que se debe realizar la restauración de manera independiente a Jest cuando se crean mocks con jest.fn().

mockFn.mockImplementation(fn) #

Acepta una función que debe ser utilizada como la implementación de la funcion a mockear. El mockeo de sí mismo aún grabará todas las llamadas que entran y casos que provienen de sí mismo, la única diferencia es que la aplicación también se ejecutará cuando se llama a la funcion mock.

Note: jest.fn(implementation) is a shorthand for jest.fn().mockImplementation(implementation).

Por ejemplo:

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 puede utilizarse también para mockear constructores 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) #

Acepta una función que se utilizará como una implementación de la funcion de mock para una llamada a la función mockeada. Puede ser encadenado para que varias llamadas de función produzcan resultados distintos.

var 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

Cuando se ejecuta la función mockeada de implementaciones definidas con mockImplementationOnce, se ejecutará la aplicación por defecto con jest.fn(() = > defaultValue) o .mockImplementation(() = > defaultValue) si se llamara:

var myMockFn = jest.fn(() => 'default')
  .mockImplementationOnce(() => 'first call')
  .mockImplementationOnce(() => 'second call');

console.log(myMockFn(), myMockFn(), myMockFn(), myMockFn());
> 'first call', 'second call', 'default', 'default'

mockFn.mockReturnThis() #

Sólo una simple función:

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');

console.log(myMockFn(), myMockFn(), myMockFn(), myMockFn());
> 'first call', 'second call', 'default', 'default'