Mocking e Stubbing no Jest: Guia Completo

O que é Mocking?

Mocking consiste em substituir uma função, módulo ou API real por uma versão simulada (falsa) que você pode controlar dentro dos testes. Isso permite que você teste unidades específicas de código sem depender de fatores externos, como chamadas a bancos de dados, APIs ou sistemas de arquivos.

Utilizando jest.mock() para Simular Módulos e Funções

A função jest.mock() é utilizada para substituir módulos completos por versões simuladas durante os testes. É especialmente útil quando você deseja evitar chamadas externas que poderiam tornar seus testes lentos ou instáveis.

Veja um exemplo prático:

Copiar
// api.js
export const fetchData = async () => {
  const response = await fetch('https://api.exemplo.com/dados');
  return response.json();
};

// api.test.js
import { fetchData } from './api';

jest.mock('./api', () => ({
  fetchData: jest.fn(() => Promise.resolve({ dados: 'Mocked Data' })),
}));

test('fetchData retorna dados mockados corretamente', async () => {
  const data = await fetchData();
  expect(data).toEqual({ dados: 'Mocked Data' });
});

Nesse exemplo, o módulo api.js é substituído por uma versão mockada que retorna dados fixos durante o teste.

Simulando APIs com jest.mock()

Você também pode usar jest.mock() para simular APIs externas, como o módulo axios.

Copiar
import axios from 'axios';
import { getUsers } from './users';

jest.mock('axios');

test('getUsers retorna lista de usuários', async () => {
  const users = [{ name: 'João' }];
  axios.get.mockResolvedValue({ data: users });

  const result = await getUsers();
  expect(result).toEqual(users);
  expect(axios.get).toHaveBeenCalledWith('/users');
});

veja um exemplo completo no artigo Criando uma API Mockada de Usuários com Testes em Jest

Espionando Funções com jest.spyOn()

Enquanto o jest.mock() substitui completamente o módulo ou função, jest.spyOn() permite "espionar" uma função real, mantendo sua implementação original ou substituindo-a temporariamente.

Por exemplo:

Copiar
const math = {
  somar: (a, b) => a + b,
};

test('espionando função somar', () => {
  const spySomar = jest.spyOn(math, 'somar');

  const resultado = math.somar(2, 3);

  expect(resultado).toBe(5);
  expect(spySomar).toHaveBeenCalledWith(2, 3);

  spySomar.mockRestore(); // restaura a implementação original
});

Se desejar alterar temporariamente a implementação da função durante o teste, pode usar:

Copiar
jest.spyOn(math, 'somar').mockImplementation(() => 10);

expect(math.somar(2, 3)).toBe(10);

O que está acontecendo aqui?

jest.spyOn(math, 'somar') Essa linha "espiona" a função original somar que pertence ao objeto math. Espionar significa que você consegue acompanhar quantas vezes a função foi chamada, quais argumentos foram usados, e também permite substituir a implementação original, se necessário.

.mockImplementation(() => 10) Aqui você está dizendo ao Jest para alterar temporariamente o comportamento da função somar. Ao invés de executar sua lógica real, agora ela irá sempre retornar o valor fixo 10.

Por que isso é útil?

É especialmente útil em situações que você precisa testar como seu código se comporta quando uma função retorna algo específico, sem executar a lógica real, que poderia depender de recursos externos ou cálculos complexos.

Dicas Importantes para Mocking no Jest

Ao utilizar mocks, tenha em mente as seguintes dicas para testes eficazes:

• Restaure mocks após testes: Sempre que utilizar jest.spyOn() ou mocks personalizados, use métodos como mockRestore() após o teste para evitar interferências entre testes.

• Mocks reutilizáveis: Utilize beforeEach ou beforeAll para criar mocks reutilizáveis e consistentes entre múltiplos testes.

• Evite excessos: Mock apenas o necessário para seus testes. Exagerar nos mocks pode tornar seus testes frágeis e difíceis de manter.

O Jest fornece ferramentas poderosas, como jest.mock() e jest.spyOn(), que tornam o processo de mockar e espionar funções extremamente fácil e eficiente. Ao dominar esses conceitos, você conseguirá escrever testes mais robustos e previsíveis, melhorando significativamente a qualidade e a estabilidade da sua aplicação.