RicardoTecPro

04-guia-professor

Leitura de 6 min

👨‍🏫 Guia do Professor - Testes Unitários com Java

Para: Prof. Ricardo
Aula: Testes Unitários com Java
Duração: 90 minutos
Nível: Intermediário

🎯 Objetivos da Sessão

O que os alunos devem sair sabendo:

  1. ✅ Conceitual: Por que testes são fundamentais para qualidade
  2. ✅ Prático: Configurar e executar JUnit 5 no VS Code
  3. ✅ Técnico: Escrever testes seguindo padrão AAA
  4. ✅ Professional: Interpretar falhas e debuggar problemas

Competências desenvolvidas:

  • Pensamento analítico (decomposição de problemas)
  • Qualidade profissional (responsabilidade com entregas)
  • Debugging sistemático (encontrar e corrigir problemas)

⏱️ Cronograma Detalhado com Dicas

📚 Bloco 1: Fundamentos (25 min)

0-5 min: Abertura

🎯 Objetivo: Ambientar e engajar

  • Faça: Pergunte sobre experiências com bugs
  • Evite: Teoria pesada logo de início
  • Dica: Use exemplo real (WhatsApp que parou, sistema do banco)

5-20 min: Conceitos fundamentais

🎯 Objetivo: Base teórica sólida

  • Slides: 🤔 Por que testar → 😱 Problemas → ✅ Benefícios
  • Interação: “Levanta a mão quem já teve bug em produção”
  • Enfoque: Aspectos econômicos (tempo = dinheiro)

20-25 min: Discussão interativa

🎯 Objetivo: Aplicar conceitos à realidade dos alunos

  • Pergunta chave: “Como vocês testam atualmente?”
  • Conduza para: Necessidade de automatização
  • Transição: “Vamos aprender a fazer isso do jeito profissional”

🔬 Bloco 2: JUnit na Prática (35 min)

25-35 min: Setup do projeto

🎯 Objetivo: Ambiente funcional para todos

⚠️ PREPARAÇÃO PRÉVIA OBRIGATÓRIA:

  • Testar internet da sala
  • Validar JDK 17+ instalado em todas as máquinas
  • VS Code com Extension Pack for Java funcionando
  • Projeto Maven template pronto para distribuir

Durante a aula:

# Comando que SEMPRE funciona:
mvn archetype:generate -DgroupId=br.com.etec.testes \
                      -DartifactId=junit-demo \
                      -DarchetypeArtifactId=maven-archetype-quickstart \
                      -DinteractiveMode=false

📋 Checklist de problemas comuns:

  • Java não encontrado: java -version no terminal
  • Maven não instalado: baixar e configurar PATH
  • VS Code sem extension: Install Extension Pack for Java
  • Projeto não abre: Fechar e reabrir pasta no VS Code

35-50 min: Primeiro teste prático

🎯 Objetivo: Demonstrar estrutura AAA

‼️ DEMONSTRAÇÃO LIVE CODING:

  1. Crie a classe primeiro:
// src/main/java/br/com/etec/testes/StringUtils.java
public class StringUtils {
    public boolean isPalindromo(String texto) {
        return false; // Implementação propositalmente errada
    }
}
  1. Depois o teste:
// src/test/java/br/com/etec/testes/StringUtilsTest.java
@Test
void deveIdentificarPalindromo() {
    StringUtils utils = new StringUtils();
    assertTrue(utils.isPalindromo("arara"));
}
  1. Execute e mostre falha (demonstrar ciclo Red-Green)
  2. Corrija implementação e mostre teste passando

🎓 Pontos pedagógicos importantes:

  • Sempre mostrar teste falhando primeiro
  • Explicar por que cada linha é necessária
  • Demonstrar como ler mensagens de erro

50-60 min: Exercício guiado

🎯 Objetivo: Alunos praticarem com segurança

ESTRATÉGIA: Pair programming dirigido

  • Divida em duplas
  • Você dita o que fazer passo a passo
  • Circule pela sala resolvendo dúvidas
  • Pare quando 70% terminarem

⏸️ Intervalo (10 min)

💡 Use este tempo para:

  • Identificar alunos com dificuldade
  • Preparar material de apoio adicional
  • Verificar se todos têm ambiente funcional

🚀 Bloco 3: Testes Avançados (15 min)

70-78 min: Testes parametrizados

🎯 Objetivo: Eficiência na escrita de testes

DEMO RÁPIDA com foco em benefício:

// Ao invés de 5 métodos iguais...
@ParameterizedTest
@ValueSource(strings = {"radar", "level", "anna", "arara", "racecar"})
void deveIdentificarPalindromos(String palindromo) {
    assertTrue(StringUtils.isPalindromo(palindromo));
}

Mensagem: “Menos código, mais casos testados”

78-85 min: Testando exceções

🎯 Objetivo: Casos especiais também devem ser testados

@Test
void deveNegarDivisaoPorZero() {
    Calculadora calc = new Calculadora();
    assertThrows(ArithmeticException.class,
                () -> calc.dividir(10, 0));
}

Enfoque: “Não basta testar o caminho feliz”

💎 Bloco 4: Consolidação (5 min)

85-90 min: Fechamento

  • Recap: 3 principais aprendizados
  • Próximos passos: TDD, Mockito, CI/CD
  • Desafio: “Apliquem em seus projetos esta semana”

🔧 Troubleshooting Durante a Aula

⚡ Soluções Rápidas (máx. 1 minuto cada)

“@Test não funciona"

// Solução padrão:
import org.junit.jupiter.api.Test;

"Teste não aparece no VS Code”

  1. Ctrl+Shift+P → “Java: Clean Workspace”
  2. Fechar e reabrir pasta
  3. Verificar Extension Pack for Java

”Maven não baixa dependências"

mvn dependency:resolve -U

"Código não compila”

  • Verificar versão Java: java -version
  • Verificar pom.xml: <maven.compiler.source>17</maven.compiler.source>

🚨 Problemas que Exigem Pausa

Mais de 3 alunos com o mesmo problema

→ PARE A AULA e resolva coletivamente

Internet instável

→ Distribua projeto pré-configurado via USB/pendrive

Máquinas muito lentas

→ Simplifique exercícios e foque mais em conceitos

🎯 Adaptações por Perfil de Turma

👥 Turma Iniciante (primeiro contato com testes)

  • 🔻 Menos tempo: Exercícios complexos
  • 🔺 Mais tempo: Conceitos fundamentais e motivação
  • ✅ Foque em: Por que testar é importante
  • 🛠️ Simplificar: Usar apenas assertEquals e assertTrue

👥 Turma Intermediária (já programa bem)

  • 🔻 Menos tempo: Setup e motivação
  • 🔺 Mais tempo: Testes parametrizados e boas práticas
  • ✅ Foque em: Qualidade profissional de código
  • 🛠️ Adicionar: Discussão sobre TDD

👥 Turma Avançada (quer desafios)

  • 🔻 Menos tempo: Conceitos básicos
  • 🔺 Mais tempo: Exercícios complexos e cenários reais
  • ✅ Foque em: Arquitetura de testes e padrões
  • 🛠️ Adicionar: Mockito, test doubles

📊 Indicadores de Sucesso

✅ Durante a aula (observar):

  • Engajamento: Fazem perguntas sobre aplicação real
  • Compreensão: Conseguem explicar AAA para o colega
  • Prática: Executam testes e interpretam resultados
  • Autonomia: Corrigem erros simples sozinhos

✅ Ao final da aula (validar):

  • Todos executam: Pelo menos um teste verde
  • Maioria implementa: Exercício guiado completo
  • Alguns avançam: Exercícios extras ou desafios
  • Feedback positivo: “Agora entendo a importância”

⚠️ Sinais de alerta (agir rápido):

  • ❌ Muitos quietos: Talvez conceito muito abstrato
  • ❌ Muitas interrupções: Ritmo muito rápido ou instruções pouco claras
  • ❌ Desistências: Ambiente não funcional ou falta de base

🚀 Sugestões de Melhoria Contínua

📈 Para próximas edições:

  1. Coleta feedback: Form anônimo no final
  2. Timing ajustado: Cronômetro rigoroso
  3. Exercícios classificados: Básico/Intermediário/Avançado
  4. Material offline: Para situações de emergência

🔄 Evoluções possíveis:

  • Aula 2: TDD na prática (Red-Green-Refactor)
  • Aula 3: Testes com banco de dados (Testcontainers)
  • Aula 4: Mockito para testar com dependências
  • Projeto: Sistema completo com 80%+ test coverage

📚 Material de Apoio para o Professor

🔗 Links importantes (ter salvos):

📁 Recursos offline essenciais:

  • Projeto Maven template configurado
  • JDK 17 installer (backup)
  • Extension Pack for Java (.vsix file)
  • Cheat sheet com principais assertions

💡 Frases de efeito para engajar:

  • “Um teste hoje economiza 10 horas de debug amanhã”
  • “Código sem teste é legado no dia que foi escrito”
  • “Se você não testa, seus usuários testarão por você”

Boa aula, Prof. Ricardo! 🎉

Lembre-se: Didática > Técnica. É melhor eles saírem empolgados e com conceitos sólidos do que confusos com muito conteúdo.

Visão de gráfico