Introdução (3 min)

Imagine um médico examinando um paciente. Ele não avalia apenas uma parte do corpo, mas realiza um check-up completo para garantir que tudo esteja funcionando corretamente. Test Coverage em APIs funciona de forma semelhante: garante que testamos todas as partes do nosso código, evitando “doenças” ocultas como bugs e comportamentos inesperados.

Em APIs modernas, com crescentes complexidades e integrações, Test Coverage é fundamental. Ele garante a qualidade, confiabilidade e a manutenibilidade do código, permitindo evoluções seguras e reduzindo os riscos de falhas em produção.

Nesta aula, vamos explorar o conceito de Test Coverage e como implementá-lo em Node.js/Express utilizando as ferramentas istanbul (via nyc) e c8. Vamos construir uma API simples e analisar como garantir que nossos testes cubram todos os aspectos da aplicação.

No contexto Node.js/Express, Test Coverage se integra perfeitamente ao fluxo de desenvolvimento, permitindo testes automatizados durante o processo de build e deploy, assegurando a qualidade da API desde o início.

Conceito Fundamental (7 min)

Test Coverage, ou cobertura de testes, mede a porcentagem do código-fonte que é executada durante a execução dos testes. Ele fornece uma visão clara de quais partes da aplicação foram efetivamente testadas e quais permanecem sem verificação, indicando potenciais pontos fracos. A terminologia da indústria inclui termos como “line coverage” (cobertura de linhas), “branch coverage” (cobertura de ramificações) e “function coverage” (cobertura de funções), representando diferentes níveis de granularidade na análise da cobertura.

Em produção, o Test Coverage é utilizado para assegurar a qualidade de APIs críticas em diversos setores, como finanças, saúde e e-commerce. Imagine uma API de pagamentos: é essencial que cada linha de código relacionada ao processamento das transações seja exaustivamente testada para evitar erros e fraudes.

O Test Coverage integra-se com ferramentas de CI/CD, como Jenkins e GitLab CI, permitindo a automação dos testes e a geração de relatórios de cobertura. A principal vantagem é a maior confiança na qualidade do código. A desvantagem pode ser o tempo adicional necessário para escrever testes que cubram todos os cenários.

Implementação Prática (10 min)

// server.js
const express = require('express');
const app = express();
const port = 3000;

function sum(a, b) {
  return a + b;
}
app.get('/soma/:a/:b', (req, res) => {
  const a = parseInt(req.params.a);
  const b = parseInt(req.params.b);
  if (isNaN(a) || isNaN(b)) {
    // Error handling robusto com logging
    console.error('Erro: Parâmetros inválidos.');
    return res.status(400).json({ error: 'Parâmetros inválidos' });
  }
  const resultado = sum(a, b);
  res.json({ resultado });
});
app.listen(port, () => {
  console.log(Servidor rodando em http://localhost:${port});
});
module.exports = { app, sum }; // Exportando para testes

// server.test.js
const request = require('supertest');
const { app, sum } = require('./server');

describe('Testes da API', () => {
  it('Soma dois números corretamente', async () => {
    const res = await request(app).get('/soma/2/3');
    expect(res.statusCode).toEqual(200);
    expect(res.body.resultado).toEqual(5);
  });
  it('Retorna erro para parâmetros inválidos', async () => {
    const res = await request(app).get('/soma/a/b');
    expect(res.statusCode).toEqual(400);
    expect(res.body.error).toEqual('Parâmetros inválidos');
  });
   it('Testa a função sum diretamente', () => {
    expect(sum(5, 5)).toBe(10);
  });
});

Instalando dependências (incluindo nyc e supertest para testes)



    
📚 Informações da Aula

    
Curso: API Completo - Node.js & Express

    
Tempo estimado: 25 minutos

    
Pré-requisitos: JavaScript básico



npm install express supertest jest nyc


Executando os testes com cobertura (usando nyc para gerar relatório da istanbul)

npx nyc --reporter=lcov --reporter=text jest


Para usar c8, instale-o:

npm install -D c8

E execute:

npx c8 jest

Exercício Hands-On (5 min)

Crie uma nova rota na API que subtraia dois números. Implemente testes que cubram os cenários de sucesso e erro (parâmetros inválidos). Execute o nyc ou c8 para verificar a cobertura dos testes e busque 100% de cobertura.

Solução:

// Adicione a rota de subtração em server.js
app.get('/subtrai/:a/:b', (req, res) => { / Implementação similar à rota /soma / });

// Adicione os testes para a nova rota em server.test.js
it('Subtrai dois números corretamente', async () => { / ... / });
it('Retorna erro para parâmetros inválidos na subtração', async () => { / ... / });

Testando e Validando:

Execute os testes com nyc --reporter=lcov --reporter=text jest ou npx c8 jest e analise o relatório gerado. Verifique se a nova rota e seus cenários estão incluídos na cobertura.

Troubleshooting:

Se encontrar erros, verifique se a nova rota e os testes estão corretamente implementados. Certifique-se de que os testes cubram todos os fluxos de código, incluindo os branches de erro.

Próximos Passos:

Explore outras métricas de cobertura, como branch coverage e function coverage, para uma análise mais aprofundada. Integre o Test Coverage ao seu processo de CI/CD para automatizar a verificação da cobertura em cada build.