RicardoTecPro

java-testes-tdd-aula

Leitura de 8 min

Tutorial: Meu Primeiro App Java com Testes (TDD)

Nesta aula, você aprenderá a criar um conversor de moedas. O diferencial é que usaremos Testes Automatizados: um código que testa o seu próprio código.

1. Preparação do Ambiente no Windows

Antes de começar, precisamos garantir que seu computador entenda Java e que o VS Code esteja pronto.

  1. JDK (Java Development Kit): Certifique-se de ter o JDK 17 ou superior instalado.
  2. VS Code: Instale o “Extension Pack for Java” da Microsoft na aba de extensões (ícone de quadradinhos).
  3. Maven: Não se preocupe em instalar manualmente; o VS Code gerencia isso para nós.

2. Criando o Projeto

  1. Abra o VS Code.
  2. Pressione Ctrl + Shift + P e digite: Java: Create Java Project.
  3. Selecione Maven → No Archetype (ou maven-archetype-quickstart).
  4. Escolha uma pasta no seu computador.
  5. GroupId: Digite br.com.aula.
  6. ArtifactId (Nome do projeto): Digite conversor-moedas.

O VS Code abrirá uma nova janela com a estrutura de pastas pronta.

3. Entendendo o arquivo pom.xml

O arquivo pom.xml é o “manual de instruções” do seu projeto. Ele diz quais ferramentas externas (dependências) o Java deve baixar.

Abra o pom.xml e verifique se dentro da tag <dependencies> existe o JUnit. Se não, adicione este bloco:

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-api</artifactId>
    <version>5.10.0</version>
    <scope>test</scope>
</dependency>

4. O Fluxo de Trabalho: Red, Green, Refactor

No desenvolvimento profissional, usamos um ciclo chamado TDD. Imagine que você é um arquiteto que testa se o material aguenta o peso antes de construir a parede.

  1. Red (Vermelho): Escrevemos um teste que falha (porque o código ainda não existe).
  2. Green (Verde): Escrevemos o código mais simples possível para o teste passar.
  3. Refactor (Refatorar): Melhoramos o código sem mudar o que ele faz.

5. Passo a Passo do Desenvolvimento

Etapa 1: O Teste que Falha (Red)

Vá na pasta src/test/java/br/com/aula e crie o arquivo ConversorTest.java. O que esperamos? Que ao enviar 10 dólares, o sistema nos devolva 50 reais.

package br.com.aula;
 
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
 
public class ConversorTest {
 
    @Test
    public void testeConverterDolarParaReal() {
        // 1. Instanciamos a classe (que ainda vai dar erro, pois não existe)
        Conversor service = new Conversor();
        
        // 2. Chamamos o método de conversão
        double resultado = service.converter(10.0);
        
        // 3. Verificamos se 10 * 5.0 é igual a 50.0
        assertEquals(50.0, resultado);
    }
}

Atenção: O VS Code vai sublinhar Conversor em vermelho. Isso é normal! Estamos no estágio “Red”.

Etapa 2: Criando o Código (Green)

Agora, vá na pasta src/main/java/br/com/aula e crie o arquivo Conversor.java.

package br.com.aula;
 
public class Conversor {
    // Definimos uma taxa fixa de 5.0 para o exemplo
    public double converter(double valorDolar) {
        return valorDolar * 5.0; 
    }
}

Etapa 3: Executando o Teste

  1. Volte para o arquivo ConversorTest.java.
  2. Acima do nome do método @Test, você verá um pequeno botão escrito Run Test. Clique nele.
  3. Se aparecer um check verde ✅, seu código está correto!

6. Testando Casos de Erro (Regras de Negócio)

E se o usuário digitar um valor negativo? O sistema não deve permitir. Vamos adicionar esse teste:

@Test
public void testeNaoDeveAceitarValorNegativo() {
    Conversor service = new Conversor();
    
    // Esperamos que o Java lance uma "Exception" (Erro) se o valor for -1.0
    try {
        service.converter(-1.0);
    } catch (IllegalArgumentException e) {
        assertEquals("Valor inválido", e.getMessage());
    }
}

Agora, ajuste o seu código em Conversor.java para validar isso:

public double converter(double valorDolar) {
    if (valorDolar < 0) {
        throw new IllegalArgumentException("Valor inválido");
    }
    return valorDolar * 5.0;
}

Resumo para o Aluno

  • src/main/java: Onde fica o “coração” do seu app.
  • src/test/java: Onde ficam os “fiscais” (testes) do seu app.
  • JUnit: A ferramenta que executa esses fiscais e te dá o relatório.

Excelente! Para consolidar o aprendizado, vamos propor um desafio prático. Aqui, o aluno não apenas escreve código, mas aprende a projetar a solução antes de abrir o editor.

🏆 Desafio Prático: O Sistema de Notas

Cenário: Você foi contratado para criar o motor de cálculo de uma escola. Sua tarefa é criar uma classe que receba três notas e calcule a média, informando se o aluno foi aprovado ou reprovado.

1. O Projeto (Diagrama de Classes)

Antes de codar, observe como a estrutura deve ser montada. No Java, representamos as ações (métodos) e os dados (atributos) assim:

2. Regras de Negócio (O que os testes devem validar)

Para este desafio, os alunos devem garantir que:

  1. A média seja calculada corretamente: .
  2. Se a média for 7.0 ou superior, o status deve ser "APROVADO".
  3. Se a média for menor que 7.0, o status deve ser "REPROVADO".
  4. As notas devem estar entre 0 e 10. Se alguém digitar 11, o sistema deve gerar um erro.

3. Passo a Passo do Aluno (Roteiro)

Passo 1: O Teste de Cálculo (Red)

No VS Code, crie CalculadoraNotasTest.java. Comece testando o cenário feliz (o aluno aprovado).

@Test
public void deveCalcularMediaComSucesso() {
    CalculadoraNotas calc = new CalculadoraNotas();
    double resultado = calc.calcularMedia(8.0, 7.0, 9.0);
    assertEquals(8.0, resultado);
}

Passo 2: A Classe de Produção (Green)

Crie a classe CalculadoraNotas.java e implemente apenas o cálculo da média para ver o teste passar.

Passo 3: O Teste de Status (Regra de Negócio)

Adicione um novo teste para verificar o texto de aprovação:

@Test
public void deveRetornarAprovadoParaMediaSete() {
    CalculadoraNotas calc = new CalculadoraNotas();
    String status = calc.obterStatus(7.0);
    assertEquals("APROVADO", status);
}

4. Dicas para o Professor (Como orientar os iniciantes)

  • O Erro é Amigo: Explique que o “sublinhado vermelho” no VS Code é o compilador avisando o que falta. Não é um erro de “burrice”, é um guia de construção.
  • A Precisão do Double: Lembre os alunos que em Java usamos . (ponto) para decimais, como 7.5, e não vírgula.
  • Atalhos do Windows: Ensine o Alt + Shift + F para formatar o código e deixá-lo bonito, e o Ctrl + . para importar classes automaticamente.

5. O que se espera ao final da aula?

O aluno deverá ter uma pasta de projeto organizada, com todos os testes exibindo o check verde no painel de testes do VS Code (ícone de um frasco de laboratório na lateral esquerda).

Dica Extra: Se o aluno terminar rápido, peça para ele tentar implementar uma regra onde notas menores que 4.0 deixam o aluno em "REPROVAÇÃO DIRETA" sem direito a recuperação.

Com certeza! Vou estruturar o material em dois formatos: um Gabarito Técnico (para você) e uma Ficha de Atividade (estilo “mão na massa” para os alunos).

📗 Gabarito Técnico (Para o Professor)

Este é o código esperado para que todos os requisitos do desafio sejam atendidos, incluindo a validação de notas entre 0 e 10.

1. Classe de Produção (CalculadoraNotas.java)

package br.com.aula;
 
public class CalculadoraNotas {
 
    public double calcularMedia(double n1, double n2, double n3) {
        // Validação de intervalo
        validarNota(n1);
        validarNota(n2);
        validarNota(n3);
        
        return (n1 + n2 + n3) / 3.0;
    }
 
    public String obterStatus(double media) {
        return media >= 7.0 ? "APROVADO" : "REPROVADO";
    }
 
    private void validarNota(double nota) {
        if (nota < 0 || nota > 10) {
            throw new IllegalArgumentException("Nota deve estar entre 0 e 10");
        }
    }
}

2. Classe de Teste (CalculadoraNotasTest.java)

package br.com.aula;
 
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
 
public class CalculadoraNotasTest {
 
    private final CalculadoraNotas calc = new CalculadoraNotas();
 
    @Test
    public void testeCalculoMediaSimples() {
        assertEquals(7.0, calc.calcularMedia(7, 7, 7));
    }
 
    @Test
    public void testeStatusAprovado() {
        assertEquals("APROVADO", calc.obterStatus(7.0));
    }
 
    @Test
    public void testeStatusReprovado() {
        assertEquals("REPROVADO", calc.obterStatus(6.9));
    }
 
    @Test
    public void testeNotaInvalidaAcimaDeDez() {
        assertThrows(IllegalArgumentException.class, () -> {
            calc.calcularMedia(11, 5, 5);
        });
    }
}

📝 Ficha de Atividade (Para o Aluno)

Nome do Aluno: _________________________________________________ Desafio: Implementação do Motor de Notas com JUnit

🎯 Missão

Você deve criar um programa que ajude professores a lançar médias. Mas atenção: o sistema precisa ser “à prova de erros” usando testes automatizados.

🚀 O que fazer?

  1. Crie o arquivo de Teste: No VS Code, em src/test/java, crie a classe CalculadoraNotasTest.
  2. Escreva o primeiro teste: Tente testar a média de 8, 8 e 8. O resultado esperado é 8.
  3. Crie a classe principal: Em src/main/java, crie a classe CalculadoraNotas para fazer o erro sumir.
  4. Implemente a lógica: Escreva o código do cálculo e rode o teste (clicando no botão “Run Test” que aparece no VS Code).

💡 Dicas de Sobrevivência no VS Code

  • A barra ficou verde? Parabéns! Seu código passou no teste.
  • A barra ficou vermelha? Leia a mensagem de erro. Ela diz exatamente o que o computador recebeu e o que ele esperava.
  • Atalho Mágico: Ctrl + . ajuda a importar as pastas necessárias automaticamente.

🏁 Checkpoint Final

Ao terminar, chame o professor se:

  • Sua classe CalculadoraNotas tiver os métodos calcularMedia e obterStatus.
  • Todos os seus testes no painel lateral do VS Code estiverem com o check verde.
  • Você conseguir explicar o que acontece se alguém tentar digitar uma nota 15.

Deseja que eu crie uma apresentação em slides (formato Markdown/Marp) que resuma esses passos para você projetar durante a aula?

Visão de gráfico