Introdução (3 min)

Imagine construir uma casa sem uma planta detalhada. Provavelmente, você encontrará problemas sérios no futuro, como paredes tortas ou encanamento mal localizado. Com APIs, o TDD (Test-Driven Development – Desenvolvimento Orientado a Testes) é essa planta, garantindo que tudo funcione como esperado antes mesmo de começar a “construção”. Este processo é fundamental para APIs modernas, pois garante a qualidade, facilita a manutenção e reduz o risco de bugs em produção.

Nesta aula, vamos construir uma rota simples em uma API Node.js/Express que realiza a soma de dois números, utilizando TDD para garantir sua robustez e confiabilidade. Este exemplo, embora simples, ilustra os princípios fundamentais do TDD em um contexto real.

Dentro do ecossistema Node.js/Express, TDD se integra perfeitamente com frameworks de teste como Jest, Mocha e Supertest, permitindo automatizar a verificação do comportamento da sua API.

Conceito Fundamental (7 min)

TDD é uma metodologia de desenvolvimento que inverte o fluxo tradicional. Em vez de escrever o código e depois os testes, primeiro escrevemos os testes que descrevem o comportamento desejado da funcionalidade, e só então implementamos o código que faz esses testes passarem.

O ciclo do TDD é conhecido como “Red-Green-Refactor”:

• Red: Escreva um teste que inicialmente falha (vermelho).
• Green: Escreva o código mínimo necessário para fazer o teste passar (verde).
• Refactor: Melhore o código, mantendo os testes passando.

Um caso de uso real em produção seria o desenvolvimento de uma API para um sistema de e-commerce. Antes de implementar a lógica para processar um pagamento, você escreveria testes que verificam se o pagamento é processado corretamente para diferentes cenários, como pagamentos com cartão de crédito, débito e boleto.

TDD se integra com diversas tecnologias, como bancos de dados (através de mocks ou integração real), frameworks de logging e sistemas de CI/CD. Suas principais vantagens são a maior confiança na qualidade do código, a redução de bugs e a facilitação da manutenção. A desvantagem é o possível aumento no tempo inicial de desenvolvimento.

Implementação Prática (10 min)

npm install express jest supertest

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

app.get('/soma/:num1/:num2', (req, res) => {
  const num1 = parseInt(req.params.num1);
  const num2 = parseInt(req.params.num2);
  // Validação robusta dos parâmetros de entrada
  if (isNaN(num1) || isNaN(num2)) {
    return res.status(400).json({ error: 'Parâmetros inválidos. Envie números inteiros.' });
  }
  const soma = num1 + num2;
  res.json({ resultado: soma });
});
// Logging profissional
app.use((req, res, next) => {
  console.log([${new Date().toISOString()}] ${req.method} ${req.url});
  next();
});
// Error handling extraordinário
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({ error: 'Erro interno do servidor' });
});
module.exports = app; // Exportando o app para os testes
if (require.main === module) { // Rodar o servidor apenas quando o arquivo for executado diretamente.
  app.listen(port, () => {
    console.log(Servidor rodando na porta ${port});
  });
}

// server.test.js
const request = require('supertest');
const app = require('./server'); // Importa o app do arquivo server.js

describe('Rota /soma', () => {
  it('deve retornar a soma de dois números', async () => {
    const res = await request(app).get('/soma/5/3');
    expect(res.statusCode).toBe(200);
    expect(res.body.resultado).toBe(8);
  });
  it('deve retornar um erro para parâmetros inválidos', async () => {
    const res = await request(app).get('/soma/a/b');
    expect(res.statusCode).toBe(400);
    expect(res.body.error).toBe('Parâmetros inválidos. Envie números inteiros.');
  });
});

npm test

Exercício Hands-On (5 min)

Crie uma nova rota /subtracao/:num1/:num2 que realiza a subtração de dois números. Utilize o TDD para garantir que a rota funcione corretamente. Lembre-se do ciclo Red-Green-Refactor.

Solução:

Primeiro, crie o teste para a nova rota:

// Em server.test.js, adicione mais um describe block
describe('Rota /subtracao', () => {
 // ... testes semelhantes aos da rota /soma
});

Em seguida, implemente a rota /subtracao no arquivo server.js, garantindo que os testes passem.

Para testar, execute npm test. Para validar o resultado, utilize um client REST como Postman ou Insomnia para testar a rota diretamente.

Erros comuns incluem a falta de await nas chamadas assíncronas com supertest e erros de digitação nos nomes das rotas ou parâmetros. Verifique o console para identificar a causa do erro.

Próximos passos: explore outros métodos HTTP (POST, PUT, DELETE) e integre com um banco de dados para persistir os dados.