Mock Functions

Funções Mock, ou de simulação, também são conhecidos como "espiões", porque elas permitem você espionar o comportamento de uma função que é chamada indiretamente por algum outro código, ao invés de apenas testando a saída. Você pode criar uma função de simulação (mock, em inglês) com jest.fn(). Se nenhuma implementação é dada, a função de simulação retornará undefined quando invocada.

Métodos #

Referência #

mockFn.mock.calls #

Uma array que representa todas as chamadas que foram feitas para esta função simulada (mock, em inglês). Cada chamada é representada por um array de argumentos que foram passados durante a chamada.

Por exemplo: uma função simulada f que tem sido chamado duas vezes, com os argumentos f('arg1', 'arg2'), e em seguida com os argumentos f('arg3', 'arg4') teria um array de mock.calls que se parece com isto:

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

mockFn.mock.instances #

Um array que contém todas as instâncias de objeto que tem sido instanciados a partir desta função simulada (mock, em inglês) usando new.

Por exemplo: uma função de simulação que foi instanciada duas vezes teria o seguinte array 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() #

Redefine todas as informações armazenadas nos arrays de mockFn.mock.calls e mockFn.mock.instances.

Muitas vezes isto é útil quando você deseja limpar os dados de uso de uma simulação entre duas afirmações.

Cuidado que mockClear irá substituir mockFn.mock, não apenas mockFn.mock.calls e mockFn.mock.instances. Portanto, evite atribuir mockFn.mock a outras variáveis, temporárias ou não, para certificar-se de que não vai acessar dados obsoletos.

A opção de configuração clearMocks está disponível para limpar as simulações automaticamente entre os testes.

mockFn.mockReset() #

Redefine todas as informações armazenadas na simulação (mock, em inglês), incluindo qualquer implementação inicial dada.

Isso é útil quando você deseja restaurar completamente uma simulação (mock, em inglês) de volta ao seu estado inicial.

Cuidado que mockClear irá substituir mockFn.mock, não apenas mockFn.mock.calls e mockFn.mock.instances. Portanto, evite atribuir mockFn.mock a outras variáveis, temporárias ou não, para certificar-se de que não vai acessar dados obsoletos.

mockFn.mockRestore() #

Remove a simulação (mock, em inglês) e restaura a implementação inicial.

Isso é útil quando você quer simular funções em certos casos de teste e restaurar a implementação original em outros.

Cuidado que mockFn.mockRestore só funciona quando a simulação foi criada com jest.spyOn. Assim, tem que cuidar da restauração você mesmo quando atribuir manualmente jest.fn().

mockFn.mockImplementation(fn) #

Aceita uma função que deve ser usada como a implementação da simulação (mock, em inglês). A simulação em si ainda irá gravar todas as chamadas que entram e instâncias que vêm dela própria – a única diferença é que a implementação também será executada quando a simulação é chamada.

Nota: jest.fn(implementation) é uma forma abreviada para jest.fn().mockImplementation(implementation).

Por exemplo:

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 também pode ser usado para simular (mock, em inglês) construtores de classe:

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

Aceita uma função que será usada como uma implementação de simulação para uma chamada à função simulada (mocked, em inglês). Podem ser encadeadas para que várias chamadas de função produzam resultados diferentes.

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

Quando a função simulada fica sem implementações definidas com mockImplementationOnce, ela irá executar o conjunto padrão de implementação com jest.fn(() => defaultValue) ou .mockImplementation(() => defaultValue) se eles foram chamados:

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

Apenas uma função simplificada para:

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

mockFn.mockReturnValue(value) #

Aceita um valor que será retornado sempre que a função de simulação é chamada.

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

mockFn.mockReturnValueOnce(value) #

Aceita um valor que será retornado por uma chamada para a função de simulação. Podem ser encadeados para que sucessivas chamadas para a função de simulação retornem valores diferentes. Quando não há mais valores mockReturnValueOnce para usar, chamadas irão retornar um valor especificado pelo 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'