Configurando testes unitários em projeto Javascript

Aprenda nesse artigo a configurar testes unitários em projetos Javascript utilizando Jest.

Porque ter testes unitários

Sem dúvida a parte de testes é uma das mais importantes na construção de qualquer aplicação, ter um ambiente de teste devidamente configurado e funcionando corretamente pode evitar inúmeras dores de cabeça com o avanço da construção da aplicação.

Os testes facilitam a validação das funcionalidades da aplicação e ainda permitem o mapeamento de falhas na evolução de cada funcionalidade que compões a aplicação, isso é de suma importância pois quando uma aplicação começa a tomar uma proporção maior, está sujeita a alterações e isso por sua vez pode acarretar em problemas quando essas alterações acontecem sem controle.

Na stack de Javascript há diversos frameworks de testes famosos e bastante utilizados no mercado, podemos citar alguns de exemplo: Jest, Mocha, Jasmine entre outros, o importante na escolha é que a equipe que está desenvolvendo a aplicação esteja familiarizada com o framework possibilitando extrair o máximo dos seus recursos.

Nossa escolha de framework foi o Jest, escolhemos ele por ser um framework já bem maduro, e bem utilizado na comunidade e em projetos relevantes.

Instalação

A instalação é bem simples, o Jest está disponível no gerenciador de pacotes padrão do Node.js, então para seguir com sua instalação precisamos apenas executar o comando padrão de instalação de qualquer pacote ou biblioteca.

npm install jest --save-dev

Configuração

Após a conclusão da instalação precisamos configurar como o Jest irá considerar os arquivos que contém os testes, para isso vamos adicionar na raiz do projeto o arquivo “jest.config.js“, nele vamos adicionar um por meio de expressão regular os arquivos que devem ser observados, segue o exemplo:

module.exports = {
  testEnvironment: 'node',
  testMatch: ['**/__tests__/**/*.js?(x)', '**/?(*.)+(spec|test).js?(x)'],
};

Essa configuração fará com que o Jest observe os arquivos que estão contidos dentro da pasta __test__, e qualquer arquivo que contenha os sufixos: “.spec.js” ou “.test.js”, esses sufixos são um padrão utilizado pela comunidade.

Com base nessa configuração é importante que você siga uma estrutura de pastas, para uma mínima organização do projeto, claro que você pode adaptar essa organização ao que mais de adéque a sua estrutura, abaixo segue o exemplo de uma organização simples:

/src
  /your_module
    your_module.js
/__tests__
  your_module.test.js

Para uma execução facilitada dos testes, verifique se no arquivo package.json tem o scripts de testes, caso na instalação não tenha sido criado, você pode adicionar, segue o exemplo:

{
    "name": "Nome do Projeto",
    "main": "src/index.js",
    "version": "1.0.0",
    "scripts": {
      "start": "npm run src/index.js",
      "test": "jest"
    },
    "dependencies": {
        // dependencias
    },
    "devDependencies": {
        // dependencias em modo dev
    }
}

Escrevendo testes

Agora que temos tudo instalado e devidamente configurado, podemos escrever de fato os testes para nossa aplicação, a sintaxe do Jest é de fácil entendimento e para implementar um teste não precisa de um conhecimento profunda do framework a baixo vamos demonstrar um exemplo de teste.

Para o nosso exemplo vamos criar um módulo da nossa aplicação que são funções matemáticas, uma das funcionalidades desse módulo é a função soma, segue a implementação abaixo:

function soma(a, b) {
  return a + b;
}

module.exports = soma;

Para testar a implementação vamos escrever um teste para ele, essa parte é bem simples precisamos apenas importar o módulo que desenvolvemos e usar os recursos que o próprio Jest nos entrega para fazer o teste de fato.

const soma = require('../src/matematica');

test('soma 1 + 2 deve retornar 3', () => {
  expect(soma(1, 2)).toBe(3);
});

test('soma 0 + 0 deve retornar 0', () => {
  expect(soma(0, 0)).toBe(0);
});

test('soma -1 + 1 deve retornar 0', () => {
  expect(soma(-1, 1)).toBe(0);
});

test('soma -1 + (-1) deve retornar -2', () => {
  expect(soma(-1, -1)).toBe(-2);
});

Vamos explicar passo a passo do que foi feito, primeiro importamos o módulo que foi desenvolvido, no nosso caso a função soma do módulo matemática.

Em seguida vamos usar a função test do Jest note que não precisamos fazer a importação dessa função basta apenas utilizá-la, como primeiro parâmetro vamos passar a descrição do teste, uma boa prática é passar a descrição de uma forma bem descritiva, e de fácil entendimento para qualquer pessoa que necessite alterar esse teste no futuro.

Como segundo parâmetro precisamos passar uma função que executará o teste de fato, vamos utilizar a função “expect” do Jest para validar o que esperamos de retorno, o retorno dessa função é uma série de outras funções que nos auxiliam na validação do retorno, no nosso caso estamos utilizando “toBe” para passar o resultado que estamos esperando.

Se o resultado for igual ao esperado, o Jest dará o teste com sucesso, em caso de qualquer outro valor ser retornado o teste será falho.

Nesse ponto que é importante fazer o uso do teste enquanto estamos desenvolvendo nossas funcionalidades, uma metodologia bem interessante é criar os testes antes mesmo de criar a funcionalidade, essa abordagem ajuda a você criar a funcionalidade para passar no teste e não o contrário.

Quando você cria testes depois da funcionalidade pronto, tem que tomar cuidado para não escrever o teste dar positivo e ignorar o real teste que deve ser feito, lembre-se o teste tem que está alinhado com a regra de negócio e não com o funcionalidade criada, a funcionalidade que tem que passar no teste, nunca o contrário.

Executando os testes

Depois dos testes devidamente codificados precisamos fazer com que o Jest valide nossos testes, para obtermos o resultado, para isso podemos utilizar o comando no terminal como no exemplo abaixo:

npm test

ou utilizar o comando

npm jest

Importante
Certifique-se de ajustar os caminhos e configurações de acordo com a estrutura e necessidades específicas do seu projeto. Lembre-se de que os testes unitários devem testar unidades individuais de funcionalidade (como funções, métodos ou classes) de forma isolada para garantir que cada parte do código funcione conforme o esperado.

Executando os testes automaticamente

O Jest tem uma funcionalidade bem interessante que permite executar os testes automaticamente quando ocorrem alterações nos arquivos do projeto, essa maneira é bem conveniente para ir validado a funcionalidade assim que você faz as alterações, para habilitar esse modo, é só utilizar o comando:

npm jest --watchAll

O interessante é que esse modo “–watchAll” irá reexecutar somente os testes que foram afetados pelas alterações, reduzindo o tempo de reexecução de testes, e sendo mais eficiente para o desenvolvedor.

Utilizando com TypeScript

Quando estamos trabalhando com Jest em projetos que usam TypeScript, é necessário adicionar algumas dependências a mais para que ele consiga compreender o TypeScript, e fazer algumas configurações a mais, segue o exemplo.

Instalação com Typescript

Na instalação em projetos que utilizam TypeScript vamos precisar adicionar a biblioteca de tipos e a ts-dev, que ajudará a interpretar o código no momento de execução dos testes, segue o exemplo do comando de instalação:

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

Configuração com TypeScript

Configure também o arquivo “tsconfig.json“, que é necessário em todos os projetos com TypeScript, mais detalhes da configuração de um projeto utilizando TypeScript pode encontrar aqui, exemplo de configuração:

{
  "compilerOptions": {
    "target": "es6",
    "module": "commonjs",
    "strict": true,
    "esModuleInterop": true
  }
}

E por último precisamos ajustar o arquivo de configuração do Jest o “jest.config.js”, para aceitar arquivos do tipo .ts:

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

A escrita dos testes continua da mesma forma, a alteração será mais nas funções que você irá testar, que devem ter tipagem, mas de forma prática não há muitas alterações.

Conclusão

Sabemos a importância de ter testes em nossas aplicações, e nesse artigo descobrimos como é fácil instalar e configurar um framework de testes bem conhecido do mercado, não é difícil encontrar o Jest em projetos por todo o mundo.

Aqui demonstramos como é simples codificar um teste para testar uma funcionalidade, você também pode descobrir muitos outros recursos que o Jest possui olhando a sua documentação oficial.