Funções de Simulação
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. 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.
Os exemplos de TypeScript desta página só funcionarão como documentados se você importar explicitamente APIs do Jest:
import {expect, jest, test} from '@jest/globals';
Consulte o guia Iniciando para obter detalhes sobre como configurar Jest com TypeScript.
Métodos
- Referência
mockFn.getMockName()
mockFn.mock.calls
mockFn.mock.results
mockFn.mock.instances
mockFn.mock.contexts
mockFn.mock.lastCall
mockFn.mockClear()
mockFn.mockReset()
mockFn.mockRestore()
mockFn.mockImplementation(fn)
mockFn.mockImplementationOnce(fn)
mockFn.mockName(name)
mockFn.mockReturnThis()
mockFn.mockReturnValue(value)
mockFn.mockReturnValueOnce(value)
mockFn.mockResolvedValue(value)
mockFn.mockResolvedValueOnce(value)
mockFn.mockRejectedValue(value)
mockFn.mockRejectedValueOnce(value)
mockFn.withImplementation(fn, callback)
- Replaced Properties
- TypeScript Usage
Referência
mockFn.getMockName()
Returns the mock name string set by calling .mockName()
.
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
Por exemplo: uma função de simulação que foi instanciada duas vezes teria o seguinte array de mock.instances
:
Redefine todas as informações armazenadas nos arrays de mockFn.mock.calls
e mockFn.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.mock.contexts
An array that contains the contexts for all calls of the mock function.
A context is the this
value that a function receives when called. The context can be set using Function.prototype.bind
, Function.prototype.call
or Function.prototype.apply
.
Por exemplo:
const mockFn = jest.fn();
const boundMockFn = mockFn.bind(thisContext0);
boundMockFn('a', 'b');
mockFn.call(thisContext1, 'a', 'b');
mockFn.apply(thisContext2, ['a', 'b']);
mockFn.mock.contexts[0] === thisContext0; // true
mockFn.mock.contexts[1] === thisContext1; // true
mockFn.mock.contexts[2] === thisContext2; // true
mockFn.mock.lastCall
An array containing the call arguments of the last call that was made to this mock function. If the function was not called, it will return undefined
.
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.lastCall
array that looks like this:
['arg3', 'arg4'];
mockFn.mockClear()
Clears all information stored in the mockFn.mock.calls
, mockFn.mock.instances
, mockFn.mock.contexts
and mockFn.mock.results
arrays. Often this is useful when you want to clean up a mocks usage data between two assertions.
The clearMocks
configuration option is available to clear mocks automatically before each tests.
Beware that mockFn.mockClear()
will replace mockFn.mock
, not just reset the values of its properties! Evite portanto atribuir mockFn.mock
a outras variáveis, temporárias ou não, para ter certeza que não acessará dados antigos.
mockFn.mockReset()
Does everything that mockFn.mockClear()
does, and also replaces the mock implementation with an empty function, returning undefined
.
The resetMocks
configuration option is available to reset mocks automatically before each test.
mockFn.mockRestore()
Does everything that mockFn.mockReset()
does, and also restores the original (non-mocked) implementation.
Isso é útil quando você quer simular funções em certos casos de teste e restaurar a implementação original em outros.
The restoreMocks
configuration option is available to restore mocks automatically before each test.
mockFn.mockRestore()
only works when the mock was created with jest.spyOn()
. Assim, tem que cuidar da restauração você mesmo quando atribuir manualmente jest.fn()
.