Como Escrever Testes Unitários em TypeScript com Jest

18/09/2024

Por Que Usar Jest com TypeScript?

Jest é uma das bibliotecas de testes unitários mais populares no ecossistema JavaScript, conhecida por sua facilidade de uso e integração com diversas ferramentas. Quando combinado com TypeScript, ele permite a criação de testes unitários com tipagem estática, garantindo a segurança dos tipos durante a execução dos testes e ajudando a identificar erros de forma antecipada. Neste artigo, vamos explorar como configurar Jest com TypeScript e como escrever testes unitários de forma eficaz.

Configurando Jest em um Projeto TypeScript

Para começar, vamos configurar o Jest em um projeto TypeScript. Aqui estão os passos necessários para preparar o ambiente de testes.

1. Instalando Dependências

Primeiro, você precisa instalar o Jest e suas dependências relacionadas ao TypeScript. No terminal, execute o seguinte comando:

npm install --save-dev jest ts-jest @types/jest

O pacote jest é a biblioteca principal de testes, ts-jest é o preset que permite compilar TypeScript dentro do Jest, e @types/jest fornece as definições de tipo para o Jest.

2. Configurando o Jest

Em seguida, crie um arquivo de configuração do Jest chamado jest.config.js na raiz do seu projeto:

module.exports = {
  preset: 'ts-jest',
  testEnvironment: 'node',
  testMatch: ['**/__tests__/**/*.test.ts']
};

Nesta configuração, estamos usando o preset ts-jest, definindo o ambiente de teste para Node.js e especificando que os testes estarão nos arquivos com a extensão .test.ts dentro da pasta __tests__.

3. Ajustando o tsconfig.json

Certifique-se de que o arquivo tsconfig.json esteja configurado para incluir o TypeScript em seu projeto de testes. Um exemplo básico de configuração seria:

{
  "compilerOptions": {
    "target": "ES6",
    "module": "commonjs",
    "strict": true,
    "esModuleInterop": true,
    "outDir": "./dist",
    "types": ["jest"]
  },
  "include": ["src/**/*", "tests/**/*"]
}

O campo types inclui as definições de tipo do Jest, garantindo que as funções e tipos de Jest sejam reconhecidos no seu projeto.

Escrevendo Testes Unitários com Jest e TypeScript

Agora que o ambiente de testes está configurado, vamos ver como escrever testes unitários básicos com Jest e TypeScript.

1. Exemplo de Função Simples

Crie uma função simples em src/somar.ts que será testada:

export function somar(a: number, b: number): number {
  return a + b;
}

2. Criando um Teste Unitário

Agora, crie um arquivo de teste em tests/somar.test.ts e escreva um teste para a função somar:

import { somar } from '../src/somar';

test('deve somar dois números corretamente', () => {
  expect(somar(2, 3)).toBe(5);
  expect(somar(-1, 1)).toBe(0);
});

Esse teste verifica se a função somar retorna o valor correto para dois cenários diferentes: somar dois números positivos e somar um número negativo e um positivo.

3. Executando os Testes

Para rodar os testes, execute o seguinte comando no terminal:

npx jest

O Jest executará todos os testes e mostrará os resultados no terminal, indicando quais testes passaram ou falharam.

Testando Funções Assíncronas

O Jest também suporta testes de funções assíncronas. Vamos ver como testar uma função que retorna uma promessa.

1. Exemplo de Função Assíncrona

Adicione uma função assíncrona em src/fetchData.ts que simula uma chamada de API:

export async function fetchData(): Promise {
  return new Promise((resolve) => {
    setTimeout(() => resolve('dados recebidos'), 1000);
  });
}

2. Escrevendo o Teste Assíncrono

Agora, crie o arquivo tests/fetchData.test.ts e escreva o teste para essa função:

import { fetchData } from '../src/fetchData';

test('deve retornar "dados recebidos" após chamada assíncrona', async () => {
  const dados = await fetchData();
  expect(dados).toBe('dados recebidos');
});

Este teste usa async/await para aguardar a resolução da função fetchData e verificar se o valor retornado está correto.

Mockando Funções com Jest

O Jest também fornece funcionalidades de mock, que permitem substituir funções reais por simulações controladas, útil para testar componentes isoladamente.

1. Exemplo de Mock

Vamos criar um exemplo onde mockamos uma função que faz uma chamada de API:

import { fetchData } from '../src/fetchData';

jest.mock('../src/fetchData');

test('mock da função fetchData', async () => {
  (fetchData as jest.Mock).mockResolvedValue('mocked data');
  
  const dados = await fetchData();
  expect(dados).toBe('mocked data');
});

Neste teste, estamos substituindo a função real fetchData por um mock que retorna um valor controlado. Isso permite que o teste se concentre no comportamento esperado, sem depender da implementação real da função.

Boas Práticas ao Escrever Testes com Jest e TypeScript

  • Teste todas as possíveis entradas e saídas: Certifique-se de que seus testes cubram diferentes cenários, incluindo casos extremos e de erro.
  • Use mocks quando necessário: Utilize mocks para isolar o comportamento de funções e evitar que os testes dependam de partes externas do sistema, como APIs ou bancos de dados.
  • Organize seus testes: Mantenha os arquivos de teste bem organizados, usando pastas e nomenclaturas consistentes. Um bom padrão é ter uma pasta __tests__ ou nomear arquivos de teste como *.test.ts.
  • Escreva testes claros e concisos: Certifique-se de que seus testes sejam fáceis de entender e focados no comportamento que estão verificando.

Conclusão

Jest, combinado com TypeScript, oferece uma poderosa ferramenta para escrever testes unitários tipados, garantindo que o código seja robusto e previsível. Com uma configuração simples, você pode integrar Jest ao seu projeto TypeScript e começar a escrever testes para funções síncronas e assíncronas, além de usar mocks para simular comportamentos. Seguindo boas práticas, seus testes serão mais eficientes e fáceis de manter, contribuindo para a qualidade do software.