25. Testes Unitários com JUnit e Mockito
Ao aprender a programar em Java, um dos aspectos mais importantes que um desenvolvedor deve dominar é a capacidade de escrever testes confiáveis e eficientes. Testes unitários são uma parte fundamental do desenvolvimento de software, pois permitem que os desenvolvedores verifiquem o comportamento de unidades individuais de código (como métodos e classes) de forma isolada. Neste capítulo, vamos explorar como você pode escrever testes unitários eficazes usando as bibliotecas JUnit e Mockito.
O que são Testes Unitários?
Testes unitários são procedimentos que verificam o funcionamento de uma "unidade" de código, que pode ser um método ou uma classe inteira. O objetivo é garantir que cada parte do software funcione corretamente de forma independente, antes de ser integrada com outras partes do sistema. Isso ajuda a identificar e corrigir erros em estágios iniciais do ciclo de desenvolvimento, o que pode economizar tempo e recursos.
Introdução ao JUnit
JUnit é uma das frameworks mais populares para escrever testes unitários em Java. Ele fornece anotações e métodos de assertiva para facilitar a verificação do comportamento esperado do código. A versão mais recente, JUnit 5, traz muitas melhorias e novas funcionalidades em comparação com seu predecessor, JUnit 4.
Escrevendo um Teste Simples com JUnit
Para começar com JUnit, você precisa criar uma classe de teste. Por convenção, o nome dessa classe geralmente é o nome da classe que será testada, seguido por "Test". Dentro dessa classe, você escreverá métodos anotados com @Test, cada um representando um caso de teste específico.
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
class CalculadoraTest {
@Test
void testarSoma() {
Calculadora calc = new Calculadora();
assertEquals(5, calc.somar(2, 3), "A soma deve ser 5");
}
}
Neste exemplo, a classe CalculadoraTest contém um método de teste testarSoma() que verifica se o método somar() da classe Calculadora está funcionando corretamente. A assertiva assertEquals() é usada para verificar se o resultado esperado (5) corresponde ao resultado obtido ao chamar calc.somar(2, 3).
Mockito para Simulação de Comportamentos
Em muitos casos, as unidades de código que você deseja testar dependem de outras classes ou recursos que podem ser difíceis de configurar ou que você não deseja invocar durante os testes unitários. É aqui que o Mockito entra em cena. Mockito é uma framework que permite criar "mocks", que são simulações de objetos reais que podem retornar dados específicos quando seus métodos são chamados.
Utilizando Mockito em Testes
Para usar Mockito, você geralmente começará criando um mock para a classe dependente usando o método mock(). Em seguida, você pode definir o comportamento desse mock com o método when(), especificando o que deve ser retornado quando métodos específicos são chamados.
import org.mockito.Mockito;
import static org.mockito.Mockito.*;
class ServicoTest {
@Test
void testarMetodo() {
Dependencia dependenciaMock = mock(Dependencia.class);
when(dependenciaMock.metodoDependente()).thenReturn("Valor Simulado");
Servico servico = new Servico(dependenciaMock);
String resultado = servico.metodoASerTestado();
assertEquals("Valor Esperado", resultado);
}
}
Neste exemplo, criamos um mock para a classe Dependencia e especificamos que, quando o método metodoDependente() for chamado, ele deve retornar "Valor Simulado". Isso permite testar o método metodoASerTestado() da classe Servico sem a necessidade de uma instância real da classe Dependencia.
Boas Práticas em Testes Unitários
Escrever testes unitários eficazes é uma arte que requer prática e atenção a detalhes. Aqui estão algumas boas práticas a seguir:
- Independência: Cada teste deve ser independente dos outros. Isso significa que a execução de um teste não deve afetar o resultado de outro.
- Repetibilidade: Um teste deve retornar o mesmo resultado toda vez que é executado, independentemente do ambiente ou da ordem de execução.
- Legibilidade: Testes devem ser fáceis de ler e entender. Isso ajuda outros desenvolvedores a compreender o que está sendo testado e por quê.
- Cobertura de Código: Busque uma boa cobertura de código com seus testes, mas lembre-se de que a qualidade dos testes é mais importante do que a quantidade.
- Teste apenas a lógica de negócios: Evite testar a infraestrutura do framework ou a linguagem de programação.
Testes unitários são uma ferramenta poderosa no arsenal de qualquer desenvolvedor Java. Com a prática, você se tornará cada vez mais eficiente em escrever testes que garantem a qualidade e a confiabilidade do seu código. Ao utilizar frameworks como JUnit e Mockito, você pode simplificar o processo de teste e focar no que realmente importa: criar um software robusto e livre de erros.
