Dúvida sobre testes antes de commites

Olá, Luidi. Tudo bem?

É uma boa prática testar o seu "Schema" antes de criar as rotas. Isso garante que o "Schema" está correto e evita que você propague erros para outras partes do seu código. Você pode fazer isso criando testes unitários que validem o "Schema" de forma isolada.

Para evitar ter que reescrever os testes de "Schema" em cada projeto, você pode criar um módulo de testes genérico ou uma biblioteca de testes que possa ser reutilizada. Por exemplo, se você estiver usando uma ferramenta de testes como o Jest, pode criar um arquivo de teste que importe o "Schema" e execute as validações necessárias. Assim, você só precisa ajustar o caminho do "Schema" quando for utilizá-lo em um novo projeto.

É possível fazer commits sem testar o "Schema", mas isso não é recomendado, pois pode introduzir erros no seu projeto. Testar antes de commitar ajuda a manter a qualidade do código e facilita a identificação de problemas.

Como exemplo prático, você pode criar um arquivo de teste como schemaTest.js que receba o "Schema" como parâmetro e execute as validações necessárias. Assim, você só precisa importar e utilizar esse arquivo em diferentes projetos.

Espero ter ajudado e bons estudos.

Tenho uma dúvida sobre testes: Quais arquivos devem ter testes? Qual é o fluxo? Primeiro cria o Schema, cria o arquivo de teste e commita; depois faz as rotas, cria arquivo de teste e commita; depois faz o controller, cria arquivo de teste e commita? Ou testa uma rota junto com a função específica do controller para depois commitar, depois testa outra rota com outra função específica do controller?

Quais arquivos precisam ter um arquivo de teste correspondente?

Olá, Luidi.

O fluxo ideal de testes pode variar conforme a abordagem do time e a complexidade do projeto, mas uma sequência recomendada é:

1. Criar o Schema e escrever um teste unitário para validar sua estrutura e regras.
2. Criar as rotas e escrever testes de integração para verificar se elas estão funcionando corretamente.
3. Criar os controllers e escrever testes para as funções individuais.

O fluxo de commits pode seguir esta estrutura:

1. Criar o Schema → Criar o teste unitário → Commit
2. Criar as rotas → Criar testes de integração → Commit
3. Criar os controllers → Criar testes unitários para cada função → Commit
4. Criar os testes end-to-end (E2E) para garantir que tudo funciona junto → Commit

Os principais arquivos que devem ter testes são:

• Schemas (testes unitários para validação de dados)
• Controllers (testes unitários para cada função)
• Rotas (testes de integração para garantir o fluxo da API)
• Serviços (caso tenha lógica separada em serviços, testar individualmente)

Veja um exemplo de teste unitário para um Schema com Jest e Joi:

const Joi = require('joi');

const schema = Joi.object({
  nome: Joi.string().required(),
  idade: Joi.number().integer().min(18).required(),
});

test('Validação do Schema', () => {
  const resultado = schema.validate({ nome: 'Luidi', idade: 25 });
  expect(resultado.error).toBeUndefined();
});

E um exemplo de teste de integração para uma rota com Supertest:

const request = require('supertest');
const app = require('../app'); // Importando a aplicação Express

test('GET /usuarios deve retornar lista de usuários', async () => {
  const resposta = await request(app).get('/usuarios');
  expect(resposta.status).toBe(200);
  expect(resposta.body).toBeInstanceOf(Array);
});

Seguindo essa abordagem, você garante que cada parte do código está funcionando antes de seguir para a próxima etapa.

Fico à disposição. Abraços e bons estudos.