O que são mocks e stubs em testes JavaScript?

O que são mocks e stubs em testes JavaScript?

Quando estamos escrevendo testes unitários em JavaScript, muitas vezes precisamos testar funções que dependem de recursos externos, como APIs, bancos de dados ou outras funções. Para evitar chamadas externas durante os testes e garantir que estamos testando apenas a lógica da função, usamos mocks e stubs.

O que são mocks?

Os mocks são objetos que simulam o comportamento de funções ou módulos externos. Eles permitem que você controle o comportamento de uma dependência dentro de um teste, garantindo que a função que você está testando se comporte corretamente, sem interagir com o mundo exterior.

Exemplo de mock com Jest:

const fetchData = jest.fn(() => Promise.resolve('data'));

test('deve retornar "data" com mock', async () => {
  const data = await fetchData();
  expect(data).toBe('data');
});

O que o código está fazendo: O código cria um mock da função fetchData usando jest.fn(), que retorna uma promise resolvida com 'data'. O teste então verifica se o mock retorna o valor esperado.

O que são stubs?

Os stubs são semelhantes aos mocks, mas eles são usados especificamente para controlar os resultados de funções que dependem de entradas externas. Enquanto os mocks geralmente verificam as chamadas feitas a uma função (como chamadas de método ou de API), os stubs são usados para substituir partes do código e retornar valores predefinidos durante os testes.

Exemplo de stub com Jest:

function getUserData() {
  return fetch('https://api.example.com/user').then(res => res.json());
}

jest.mock('node-fetch', () => jest.fn());

test('deve retornar dados do usuário com stub', () => {
  fetch.mockResolvedValueOnce({ name: 'John' });
  return getUserData().then(data => {
    expect(data.name).toBe('John');
  });
});

O que o código está fazendo: O código substitui a função fetch com um stub que retorna um valor predefinido. Em vez de fazer uma chamada real para a API, o stub retorna { name: 'John' }, permitindo testar a função getUserData sem depender de uma resposta externa.

Diferença entre mocks e stubs

A principal diferença entre mocks e stubs é o propósito:

• Mocks são usados para verificar se as funções foram chamadas corretamente e se o comportamento esperado foi realizado. Eles são mais focados em interação.
• Stubs são usados para substituir o comportamento de funções e fornecer valores predefinidos durante o teste. Eles são mais focados em substituição de comportamento.

Ambos os conceitos são ferramentas essenciais para isolar partes do código e garantir que você esteja testando a lógica de forma precisa e sem interferências externas.

Como usar mocks e stubs no Jest

O Jest oferece uma série de ferramentas poderosas para trabalhar com mocks e stubs. Com o jest.fn(), você pode criar mocks para funções e métodos. Já para stubs, você pode usar jest.mock() para substituir módulos inteiros ou funções específicas.

Exemplo de substituição de módulo com Jest:

jest.mock('axios');

import axios from 'axios';

axios.get.mockResolvedValue({ data: 'response' });

test('deve retornar dados usando mock de axios', async () => {
  const response = await axios.get('/api/data');
  expect(response.data).toBe('response');
});

O que o código está fazendo: O código substitui o módulo axios com um mock usando jest.mock(). Ele simula a chamada axios.get() e retorna uma resposta mockada, permitindo que o teste valide o comportamento sem precisar fazer uma solicitação real para o servidor.

Como evitar efeitos colaterais ao usar mocks e stubs?

Ao usar mocks e stubs, é importante garantir que você limpe o estado entre os testes para evitar efeitos colaterais. O Jest oferece funções como jest.clearAllMocks() e jest.resetAllMocks() para restaurar o estado dos mocks e stubs entre os testes.

Exemplo de limpeza de mocks:

afterEach(() => {
  jest.clearAllMocks();
});

O que o código está fazendo: A função afterEach é executada após cada teste e usa jest.clearAllMocks() para limpar o estado de todos os mocks, garantindo que o próximo teste não seja afetado por chamadas anteriores.

Conclusão

Mocks e stubs são ferramentas essenciais para testar JavaScript de forma eficaz, permitindo que você isole o código e controle as dependências externas. Usando Jest, você pode facilmente criar mocks e stubs para testar funções complexas, melhorar a confiabilidade dos testes e garantir que seu código se comporte conforme esperado em diferentes cenários.

Como mocks e stubs melhoram a eficácia dos testes em JavaScript

Trabalhar com mocks e stubs em JavaScript é uma maneira poderosa de testar seu código sem depender de fatores externos. Eles permitem que você simule e controle o comportamento de funções e módulos durante os testes, o que torna a validação da lógica do código muito mais eficaz. Além disso, o uso de mocks e stubs ajuda a melhorar a qualidade do código e permite que você escreva testes mais robustos e confiáveis.

Algumas aplicações:

• Utilize mocks para simular funções e verificar como o código interage com elas.
• Use stubs para substituir o comportamento de funções e fornecer valores controlados durante os testes.
• Limpe os mocks e stubs entre os testes usando funções como jest.clearAllMocks() para evitar efeitos colaterais.

Dicas para quem está começando

• Comece a escrever mocks e stubs simples e depois adicione complexidade à medida que se sentir mais confortável.
• Verifique sempre os efeitos colaterais dos mocks e stubs, garantindo que eles não afetem outros testes.
• Use Jest para criar mocks e stubs de forma eficiente e com boa cobertura de testes.

Compartilhe este tutorial