Como evitar efeitos colaterais em testes JavaScript e garantir testes confiáveis

Como evitar efeitos colaterais em testes JavaScript?

Testes unitários em JavaScript são fundamentais para garantir que o código esteja funcionando corretamente, mas um dos maiores desafios é evitar efeitos colaterais. Efeitos colaterais ocorrem quando um teste influencia o comportamento de outros testes ou o estado global do aplicativo. Isso pode fazer com que os resultados dos testes não sejam confiáveis, o que pode levar a falhas não detectadas em produção.

O que são efeitos colaterais?

Efeitos colaterais são mudanças no estado do sistema que afetam outros testes ou partes do código. Esses efeitos podem ser causados por variáveis globais, modificações em objetos mutáveis, ou chamadas de funções que alteram o ambiente de teste.

Exemplo de efeito colateral com variáveis globais:

let counter = 0;

function incrementCounter() {
  counter += 1;
}

test('testa incremento de contador', () => {
  incrementCounter();
  expect(counter).toBe(1);
});

test('testa incremento de contador novamente', () => {
  expect(counter).toBe(1);  // Erro! O valor deveria ser 0, não 1
});

O que o código está fazendo: No exemplo acima, a variável counter é global e é compartilhada entre os testes. O primeiro teste modifica seu valor, e o segundo teste falha porque ele depende do valor inicial de counter, causando um efeito colateral.

Como isolar testes e evitar efeitos colaterais?

A maneira mais comum de evitar efeitos colaterais é garantir que os testes sejam isolados. Isso significa que cada teste deve ser capaz de rodar de forma independente, sem depender do estado de outros testes. Uma prática importante é limpar ou redefinir variáveis, objetos ou mocks entre os testes.

Usando `beforeEach` e `afterEach` no Jest

Jest fornece funções como beforeEach() e afterEach() para configurar e limpar o estado antes e depois de cada teste. Isso garante que cada teste comece em um estado limpo, sem interferência de testes anteriores.

Exemplo de limpeza de mocks com `afterEach()`:

let mockFn;

beforeEach(() => {
  mockFn = jest.fn();
});

test('testa mock', () => {
  mockFn('argumento');
  expect(mockFn).toHaveBeenCalledWith('argumento');
});

afterEach(() => {
  jest.clearAllMocks();  // Limpa todos os mocks após o teste
});

O que o código está fazendo: O código usa beforeEach() para configurar o mock mockFn antes de cada teste e afterEach() para limpar os mocks depois de cada execução. Isso garante que o mock esteja limpo e não afete outros testes.

Limpeza de objetos mutáveis

Outro exemplo de efeito colateral é a modificação de objetos ou arrays entre os testes. Se você está utilizando objetos mutáveis em seus testes, é importante garantir que esses objetos sejam restaurados ou copiados após cada teste.

Exemplo de objeto mutável:

let user = { name: 'John' };

function changeName(newName) {
  user.name = newName;
}

test('deve alterar nome', () => {
  changeName('Jane');
  expect(user.name).toBe('Jane');
});

test('não deve afetar o teste anterior', () => {
  expect(user.name).toBe('John');  // Erro! O nome foi alterado no teste anterior
});

O que o código está fazendo: O objeto user é modificado em um teste e afeta o valor no outro, causando um efeito colateral. A melhor prática seria copiar o objeto para que ele não seja alterado entre os testes.

Usando `jest.resetModules()` para limpar caches de módulos

Em testes que dependem de módulos importados, você pode usar jest.resetModules() para limpar os caches dos módulos entre os testes. Isso garante que os módulos sejam recarregados e não sejam afetados por modificações realizadas em outros testes.

Exemplo de limpeza de módulos com `resetModules()`:

beforeEach(() => {
  jest.resetModules();  // Reseta todos os módulos importados
});

test('deve testar módulo corretamente', () => {
  const myModule = require('./myModule');
  expect(myModule.doSomething()).toBe(true);
});

O que o código está fazendo: O código usa jest.resetModules() no beforeEach() para garantir que os módulos sejam recarregados e não sejam afetados por alterações feitas durante outros testes.

Como evitar efeitos colaterais em testes assíncronos?

Quando estamos lidando com funções assíncronas, é especialmente importante limpar o estado entre os testes. Se você estiver utilizando funções assíncronas ou temporizadores, use jest.useFakeTimers() ou jest.runAllTimers() para controlar e simular o comportamento do código assíncrono durante os testes.

Exemplo com `useFakeTimers()`:

jest.useFakeTimers();

test('deve simular atraso sem efeitos colaterais', () => {
  const callback = jest.fn();
  setTimeout(callback, 1000);
  jest.runAllTimers();
  expect(callback).toHaveBeenCalled();
});

O que o código está fazendo: O código usa jest.useFakeTimers() para simular o atraso e jest.runAllTimers() para avançar todos os timers. Isso evita que os testes sejam afetados por delays reais, garantindo uma execução mais rápida e controlada.

Conclusão

Evitar efeitos colaterais nos testes JavaScript é fundamental para garantir que cada teste seja executado isoladamente e de forma previsível. Usando ferramentas como beforeEach(), afterEach(), jest.resetModules(), e jest.clearAllMocks(), você pode isolar seu código de maneira eficaz e evitar que alterações em um teste afetem outros. Adotar essas boas práticas de isolamento de testes garante que seu código seja confiável, fácil de manter e sem comportamentos inesperados.

Boas práticas para evitar efeitos colaterais nos testes em JavaScript

Quando você começa a escrever testes unitários em JavaScript, um dos maiores desafios é garantir que os testes sejam isolados. Isso significa que as alterações feitas por um teste não devem afetar outros testes. Para evitar efeitos colaterais, é necessário adotar boas práticas, como limpar mocks, restaurar o estado de objetos e módulos e controlar o comportamento assíncrono. Isso garante que os testes sejam executados em um estado previsível e que os resultados sejam sempre confiáveis.

Algumas aplicações:

Use jest.clearAllMocks() para limpar mocks entre os testes e evitar efeitos colaterais de dependências simuladas.
Implemente beforeEach() e afterEach() para configurar e limpar o estado antes e depois dos testes.
Teste funções assíncronas de maneira controlada usando jest.useFakeTimers() e jest.runAllTimers().

Dicas para quem está começando

Comece com mocks simples e adicione complexidade aos poucos à medida que for entendendo como controlar o estado.
Sempre que possível, isole funções que fazem modificações no estado para evitar efeitos colaterais.
Testar funções assíncronas pode ser mais desafiador, então pratique usando async/await junto com mocks e stubs.

Contribuições de Cláudia Medeiros

Como evitar efeitos colaterais em testes JavaScript?