DS & II

🚀 Capítulo 12: Testes Unitários e Mockito

Leitura de 5 min

🚀 Capítulo 12: Testes Unitários e Mockito

🎯 Objetivo da Aula

Ao final desta aula, você será capaz de escrever testes unitários utilizando o JUnit 5, simular dependências com o Mockito e compreender o fluxo de desenvolvimento guiado por testes (TDD).

🏢 O Cenário Prático (Seu Desafio)

Você é Lucius Fox, o engenheiro chefe das Indústrias Wayne. O seu desafio é garantir que os equipamentos do cinto de utilidades do Batman funcionem perfeitamente antes de ele ir para as ruas de Gotham. Para isso, você deve criar testes automatizados para validar o software dos dispositivos.

🧠 Fundamentos: A Teoria Traduzida

Testar software manualmente é lento e passível de falhas. Por isso, na engenharia de software moderna, usamos testes automatizados.

  • Teste Unitário: Testa a menor parte do sistema (geralmente um único método) de forma isolada. (Ex: Testar se o lançador de ganchos trava na altura correta).
  • JUnit 5: É a biblioteca padrão que usamos em Java para criar e rodar esses testes.
  • Mockito: Serve para criar “objetos dublês” (mocks). Use quando o método que você quer testar depende de algo externo que você não quer ou não pode acessar agora (ex: O sinal de GPS do satélite da Liga da Justiça).

Ciclo do TDD (Red, Green, Refactor)

  1. Red: Escreva um teste que falha (pois o código ainda não existe).
  2. Green: Escreva o código mais simples para fazer o teste passar.
  3. Refactor: Melhore o código mantendo o teste passando.

📖 Exemplo Guiado

Vamos testar o sistema de cálculo de combustível do Batmóvel.

  1. Crie a classe Batmovel.java (O código que queremos testar):
public class Batmovel {
    public boolean calcularAutonomia(int combustivel, int distancia) {
        // Cada litro rende 10km
        return combustivel * 10 >= distancia;
    }
}
  1. Crie a classe de teste BatmovelTest.java (Usando JUnit 5):
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
 
public class BatmovelTest {
 
    @Test
    public void deveTerAutonomiaSuficiente() {
        Batmovel batmovel = new Batmovel();
        
        // Se tenho 10 litros, devo conseguir andar 100km
        boolean resultado = batmovel.calcularAutonomia(10, 100);
        
        // Verifica se o resultado é verdadeiro
        assertTrue(resultado, "O Batmóvel deveria ter autonomia!");
    }
}

🕹️ Como Executar os Testes no VS Code

  1. Abra o arquivo BatmovelTest.java.
  2. Você verá um pequeno link escrito Run Test (ou uma seta verde) logo acima da linha @Test.
  3. Clique em Run Test.
  4. O VS Code abrirá a aba “Test Results” e você deverá ver uma barra verde indicando que o teste passou!

Resultado Esperado:

TesteEntradaSaída Esperada
deveTerAutonomiaSuficientecombustivel=10, distancia=100Sucesso (Barra Verde)

🛠️ Prática Obrigatória 1

Crie uma classe chamada Dispositivo com o método boolean verificarIntegridade(int energia). O método retorna true se a energia for maior que 50. Crie uma classe de teste usando JUnit 5 para validar esse comportamento (crie um teste que espera true com energia 60 e outro que espera false com energia 40).

Resultado Esperado:

TesteEntradaSaída Esperada
deveSerIntegroenergia=60Sucesso (Barra Verde)
naoDeveSerIntegroenergia=40Sucesso (Barra Verde)

🛠️ Prática Obrigatória 2

Imagine que o sistema de rádio do Batman depende de um ServidorFrequencia externo. Como não temos o servidor real agora, use o Mockito para simular o comportamento dele. Crie o teste onde o mock do servidor deve fingir que está ativo (retornar true para o método estaAtivo()).

Resultado Esperado:

TesteComportamento SimuladoSaída Esperada
deveFuncionarComServidorAtivoestaAtivo() retorna trueSucesso (Barra Verde)

📤 Instruções de Entrega (GitHub Desktop + Microsoft Teams)

Neste curso, você entregará suas atividades enviando o código para o seu repositório no GitHub usando o aplicativo GitHub Desktop. Siga o passo a passo detalhado:

  1. Verifique a estrutura: Certifique-se de que sua estrutura de pastas final está idêntica à mostrada abaixo.
  2. Abra o GitHub Desktop: Certifique-se de que o repositório do seu curso está selecionado no canto superior esquerdo.
  3. Visualize as alterações: Na aba Changes (à esquerda), você verá todos os arquivos que criou ou modificou nesta aula.
  4. Faça o Commit:
    • No campo Summary (na parte inferior esquerda), digite uma mensagem curta descrevendo o que fez, ex: Finaliza atividades do Capítulo 12.
    • Clique no botão azul Commit to main (ou o nome da sua branch).
  5. Envie para a Nuvem (Push): No topo da tela, clique no botão Push origin. Isso enviará seu código do seu computador para o seu perfil no GitHub.
  6. ⚠️ IMPORTANTE (Repositório Público): Para que o professor consiga corrigir, o seu repositório no GitHub DEVE SER PÚBLICO. Repositórios privados não podem ser visualizados por quem não foi convidado.
  7. Como entregar no Microsoft Teams:
    • Copie o link do seu repositório no GitHub (ex: https://github.com/seu-usuario/seu-repositorio).
    • Abra a tarefa correspondente no Microsoft Teams.
    • Clique no botão Adicionar trabalho (ou Add work).
    • Selecione a opção Link no menu lateral.
    • Cole o link do GitHub no campo “Endereço Web” e digite um texto (ex: Meu Repositório) no campo “Texto a ser exibido”.
    • Clique em Anexar.
    • MUITO IMPORTANTE: Clique no botão Entregar (ou Turn in) no canto superior direito para concluir o envio!

💡 Checkpoint de Lógica

O que você acabou de fazer é garantir a qualidade do software. Em grandes empresas, nenhum código vai para produção sem passar por uma bateria de centenas de testes automatizados. É a sua rede de segurança contra bugs!

🔥 Desafio de Fixação (Opcional)

Aplique o TDD (escreva o teste primeiro!) para criar um método que valide se uma senha de acesso ao Batcomputador é forte (tem mais de 8 caracteres).

🔑 Gabarito de Código/Fórmulas

Prática 1:

// Classe
public class Dispositivo {
    public boolean verificarIntegridade(int energia) {
        return energia > 50;
    }
}
 
// Teste
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
 
public class DispositivoTest {
    @Test
    public void deveSerIntegro() {
        Dispositivo d = new Dispositivo();
        assertTrue(d.verificarIntegridade(60));
    }
    
    @Test
    public void naoDeveSerIntegro() {
        Dispositivo d = new Dispositivo();
        assertFalse(d.verificarIntegridade(40));
    }
}

Prática 2:

import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
 
public class RadioTest {
    @Test
    public void deveFuncionarComServidorAtivo() {
        // Criando o mock da interface ou classe
        ServidorFrequencia mockServidor = mock(ServidorFrequencia.class);
        
        // Configurando o comportamento simulado
        when(mockServidor.estaAtivo()).thenReturn(true);
        
        // Testando usando o mock
        assertTrue(mockServidor.estaAtivo());
    }
}

Desafio:

// Teste Primeiro!
@Test
public void deveValidarSenhaForte() {
    Validador v = new Validador();
    assertTrue(v.isForte("batman123")); // Deve retornar true
}

← Capitulo Anterior | Proximo Capitulo →

Visão de gráfico

Backlinks