RicardoTecPro

plano-de-aula-tdd-java

Leitura de 5 min

📚 Plano de Aula: Desenvolvimento com TDD em Java

Curso: Técnico em Informática
Data: 02/03/2026
Duração: 100 minutos (2 aulas)
Professor: [Ricardo]

🎯 Objetivos da Aula

Objetivos Específicos

  • Teóricos:

    • Compreender os conceitos de TDD (Test-Driven Development)
    • Entender o ciclo Red-Green-Refactor
    • Conhecer a importância dos testes automatizados no desenvolvimento
    • Identificar diferenças entre código de produção e código de teste

  • Práticos:

    • Configurar ambiente Java com Maven e JUnit
    • Implementar testes unitários usando JUnit 5
    • Aplicar TDD na criação de um conversor de moedas
    • Executar testes no VS Code
    • Validar regras de negócio através de testes

Competências Desenvolvidas

  • Programação orientada a objetos em Java
  • Metodologias de desenvolvimento ágil
  • Qualidade de software
  • Debugging e resolução de problemas

📖 Conteúdo Teórico

1. Introdução ao TDD (15 min)

O que é Test-Driven Development?

TDD é uma prática de desenvolvimento onde escrevemos os testes antes do código de produção. É como construir o teste de qualidade antes de fabricar o produto.

Os Três Pilares do TDD: Red-Green-Refactor

  1. 🔴 Red (Vermelho): Escreva um teste que falha

    • O teste define o que você quer que o código faça
    • É normal que dê erro - o código ainda não existe!

  2. 🟢 Green (Verde): Escreva o código mais simples para passar no teste

    • Não se preocupe com elegância agora
    • Objetivo: fazer o teste passar

  3. 🔵 Refactor (Azul): Melhore o código sem mudar o comportamento

    • Remova duplicação
    • Melhore legibilidade
    • Optimize performance

Por que usar TDD?

Vantagens:

  • ✅ Garante que o código funciona conforme esperado
  • ✅ Documenta o comportamento do sistema
  • ✅ Facilita mudanças futuras (refactoring seguro)
  • ✅ Reduz bugs em produção
  • ✅ Melhora o design do código

Analogia: É como ter um “fiscal” que sempre verifica se sua obra está de acordo com o projeto.

2. Ferramentas e Ambiente (10 min)

JUnit 5

  • Framework de testes para Java
  • Anotações principais: @Test, @BeforeEach, @AfterEach
  • Métodos de assertivas: assertEquals(), assertTrue(), etc.

Maven

  • Gerenciador de dependências
  • Arquivo pom.xml define as bibliotecas do projeto
  • Estrutura padronizada de pastas

VS Code + Extension Pack for Java

  • IDE integrada com suporte completo ao Java
  • Execução de testes visuais
  • Debug integrado

💻 Atividades Práticas

Atividade 1: Configuração do Ambiente (15 min)

Pré-requisitos

  1. Verificar instalação do JDK:

    java --version

  2. Criar projeto Maven:

    • Ctrl + Shift + P → “Java: Create Java Project”
    • Selecionar Maven → No Archetype
    • GroupId: br.com.aula
    • ArtifactId: conversor-moedas

  3. Configurar pom.xml:

     
<properties>
 <maven.compiler.source>17</maven.compiler.source>
 <maven.compiler.target>17</maven.compiler.target>
 <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 <junit.version>5.10.0</junit.version>
 
<dependencies>
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-api</artifactId>
    <version>5.10.0</version>
    <scope>test</scope>
</dependency>
</dependencies>

Atividade 2: Primeiro Teste (TDD na Prática) (25 min)

Cenário: Conversor de Dólar para Real

Regra de Negócio: 1 USD = 5.0 BRL

Passo 1: Red 🔴

Arquivo: src/test/java/br/com/aula/ConversorTest.java

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() {
     // Arrange (Preparar)
     Conversor conversor = new Conversor();
 
     // Act (Agir)
     double resultado = conversor.converter(10.0);
 
     // Assert (Verificar)
     assertEquals(50.0, resultado);
 }
}

Resultado esperado: Erro de compilação - Conversor não existe ainda!

Passo 2: Green 🟢

Arquivo: src/main/java/br/com/aula/Conversor.java

package br.com.aula;
 
public class Conversor {
    public double converter(double valorDolar) {
        return valorDolar * 5.0;
    }
}

Resultado esperado: Teste passa! ✅

Passo 3: Refactor 🔵

package br.com.aula;
 
public class Conversor {
    private static final double TAXA_USD_BRL = 5.0;
 
    public double converter(double valorDolar) {
        return valorDolar * TAXA_USD_BRL;
    }
}

Atividade 3: Testando Regras de Negócio (20 min)

Cenário: Validação de Entrada

Nova Regra: Não aceitar valores negativos

Teste para Valor Negativo:

@Test
public void testeNaoDeveAceitarValorNegativo() {
    Conversor conversor = new Conversor();
 
    assertThrows(IllegalArgumentException.class, () -> {
        conversor.converter(-1.0);
    });
}

Implementação da Validação:

public double converter(double valorDolar) {
    if (valorDolar < 0) {
        throw new IllegalArgumentException("Valor deve ser positivo");
    }
    return valorDolar * TAXA_USD_BRL;
}

Atividade 4: Execução de Testes no VS Code (10 min)

Métodos de Execução:

  1. Botão “Run Test”: Aparece acima de @Test
  2. Clique direito: Menu de contexto
  3. Test Explorer: Painel lateral (🧪)
  4. Command Palette: Ctrl + Shift + P → “Java: Run Tests”
  5. Terminal: mvn test

Interpretando Resultados:

  • ✅ Verde: Teste passou
  • ❌ Vermelho: Teste falhou
  • ⚠️ Amarelo: Teste ignorado

🏆 Desafio Prático

Sistema Calculadora de Notas

Especificação:

  • Calcular média de 3 notas
  • Determinar status: “APROVADO” (≥7.0) ou “REPROVADO” (<7.0)
  • Validar notas entre 0 e 10

Roteiro TDD:

1. Teste do Cálculo de Média:

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

2. Teste do Status de Aprovação:

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

3. Teste de Validação:

@Test
public void deveRejeitarNotaInvalida() {
    CalculadoraNotas calc = new CalculadoraNotas();
    assertThrows(IllegalArgumentException.class, () -> {
        calc.calcularMedia(11.0, 5.0, 8.0);
    });
}

📝 Avaliação

Critérios de Avaliação:

  1. Configuração do ambiente (20%)
  2. Implementação dos testes (30%)
  3. Código de produção funcionando (30%)
  4. Boas práticas de TDD (20%)

Entrega:

  • Projeto Maven funcional
  • Todos os testes passando (🟢)
  • Código documentado
  • Demonstração do funcionamento

🔍 Conceitos-Chave

Glossário:

  • Assertion: Verificação de uma condição esperada
  • Test Case: Caso de teste individual
  • Test Suite: Conjunto de testes
  • Mock: Objeto simulado para testes
  • Coverage: Cobertura de código pelos testes

Boas Práticas:

  • ✅ AAA Pattern: Arrange, Act, Assert
  • ✅ Nomes descritivos: deveCalcularMediaCorretamente()
  • ✅ Um conceito por teste: Teste simples e focado
  • ✅ Testes independentes: Não dependem uns dos outros
  • ✅ Rápidos: Execução em poucos segundos

📚 Material de Apoio

Exercícios para Casa:

  1. Implementar conversor Euro → Real
  2. Adicionar testes para valores zero
  3. Criar calculadora de IMC com TDD

Próxima Aula:

  • Testes de integração
  • Mocking com Mockito
  • CI/CD com GitHub Actions

📋 Anotações do Professor

Tempo Sugerido:

  • 0-15min: Teoria TDD
  • 15-25min: Configuração ambiente
  • 25-50min: Prática conversor
  • 50-70min: Regras de negócio
  • 70-85min: Desafio calculadora
  • 85-100min: Apresentação resultados

Dificuldades Comuns:

  • Import automático: Usar Ctrl + .
  • Separador decimal: Usar ponto (.) não vírgula (,)
  • Package: Verificar se está correto em ambas as classes
  • Maven reload: Se dependências não carregarem, F1 → “Java: Reload Projects”

Adaptações:

  • Turma iniciante: Focar apenas no conversor básico
  • Turma avançada: Incluir testes parametrizados e cobertura

Este plano de aula foi desenvolvido seguindo as melhores práticas pedagógicas para ensino de programação orientada a testes.

Visão de gráfico

Backlinks