Pular para o conteúdo principal

Capítulo 2: Testes Unitários com JUnit 5

Introdução​

JUnit 5 é o framework de testes padrão para Java. É a base de todos os seus testes Spring Boot. Este capítulo ensina como utilizá-lo de forma eficiente.

🎯 Objetivos do Capítulo​

Ao final deste capítulo, você saberá:

  1. ✅ Utilizar as anotações do JUnit 5
  2. ✅ Escrever asserções claras
  3. ✅ Testar exceções
  4. ✅ Criar testes parametrizados
  5. ✅ Gerenciar o ciclo de vida dos testes

1. Estrutura de um Teste​

Anatomia Básica​

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

class CalculatorTest {

    @Test  // ← Indica um método de teste
    void shouldAddTwoNumbers() {
        // Arrange (Preparar)
        Calculator calc = new Calculator();
        
        // Act (Executar)
        int result = calc.add(2, 3);
        
        // Assert (Verificar)
        assertEquals(5, result);
    }
}

Convenções​

class ProductServiceTest {  // ← Nome: ClasseTestada + Test
    
    @Test
    void shouldReturnProductById() {  // ← Método descritivo
        // ...
    }
    
    @Test
    void shouldThrowExceptionWhenProductNotFound() {
        // ...
    }
}

2. Anotações Principais​

@Test​

import org.junit.jupiter.api.Test;

@Test
void simpleTest() {
    assertTrue(1 + 1 == 2);
}

@DisplayName​

@Test
@DisplayName("Deve calcular o preço com IVA de 20%")
void shouldCalculatePriceWithVAT() {
    double result = priceService.calculateWithVAT(100.0, 0.20);
    assertEquals(120.0, result);
}

@Disabled​

@Test
@Disabled("Aguardando correção do bug #123")
void brokenTest() {
    // Este teste será ignorado
}

@BeforeEach e @AfterEach​

class ProductServiceTest {
    
    private ProductService productService;
    
    @BeforeEach
    void setUp() {
        // Executado ANTES de cada teste
        productService = new ProductService();
    }
    
    @AfterEach
    void tearDown() {
        // Executado DEPOIS de cada teste (limpeza)
        productService = null;
    }
    
    @Test
    void test1() { /* productService está novo */ }
    
    @Test
    void test2() { /* productService está novo */ }
}

@BeforeAll e @AfterAll​

class DatabaseTest {
    
    @BeforeAll
    static void setUpAll() {
        // Executado UMA VEZ antes de todos os testes
        // Deve ser static!
        System.out.println("Inicialização global...");
    }
    
    @AfterAll
    static void tearDownAll() {
        // Executado UMA VEZ após todos os testes
        System.out.println("Limpeza global...");
    }
}

Ordem de Execução​

@BeforeAll (1 vez)
│
├── @BeforeEach
│   └── @Test test1()
│   └── @AfterEach
│
├── @BeforeEach
│   └── @Test test2()
│   └── @AfterEach
│
└── @AfterAll (1 vez)

3. Asserções​

Asserções Básicas​

import static org.junit.jupiter.api.Assertions.*;

@Test
void demonstrateAssertions() {
    // Igualdade
    assertEquals(5, calculator.add(2, 3));
    assertEquals("Hello", greeting.getMessage());
    assertEquals(3.14, Math.PI, 0.01);  // Com delta para double
    
    // Booleanos
    assertTrue(user.isActive());
    assertFalse(list.isEmpty());
    
    // Null
    assertNull(optionalValue.orElse(null));
    assertNotNull(service.findById(1L));
    
    // Referências
    assertSame(expected, actual);      // Mesmo objeto
    assertNotSame(obj1, obj2);         // Objetos diferentes
}

Asserções em Coleções​

@Test
void testCollections() {
    List<String> fruits = List.of("Apple", "Banana", "Cherry");
    
    // Tamanho
    assertEquals(3, fruits.size());
    
    // Conteúdo
    assertTrue(fruits.contains("Apple"));
    assertFalse(fruits.contains("Grape"));
    
    // Com AssertJ (mais legível)
    assertThat(fruits)
        .hasSize(3)
        .contains("Apple", "Banana")
        .doesNotContain("Grape")
        .startsWith("Apple")
        .endsWith("Cherry");
}

Mensagens Personalizadas​

@Test
void testWithMessage() {
    int age = user.getAge();
    
    assertTrue(age >= 18, "O usuário deve ser maior de idade");
    assertEquals(25, age, () -> "A idade esperada era 25 mas era " + age);
}

assertAll (Asserções Agrupadas)​

@Test
void testUserProperties() {
    User user = new User("John", "john@email.com", 25);
    
    // Todas as asserções são executadas, mesmo se uma falhar
    assertAll("Propriedades do usuário",
        () -> assertEquals("John", user.getName()),
        () -> assertEquals("john@email.com", user.getEmail()),
        () -> assertEquals(25, user.getAge()),
        () -> assertTrue(user.isActive())
    );
}

4. Testando Exceções​

assertThrows​

@Test
void shouldThrowExceptionWhenDividingByZero() {
    Calculator calc = new Calculator();
    
    // Verifica se a exceção é lançada
    assertThrows(ArithmeticException.class, () -> {
        calc.divide(10, 0);
    });
}

@Test
void shouldThrowExceptionWithMessage() {
    // Captura a exceção para verificar a mensagem
    IllegalArgumentException exception = assertThrows(
        IllegalArgumentException.class,
        () -> userService.createUser(null)
    );
    
    assertEquals("Username cannot be null", exception.getMessage());
}

assertDoesNotThrow​

@Test
void shouldNotThrowException() {
    assertDoesNotThrow(() -> {
        userService.createUser("validUser");
    });
}

5. Testes Parametrizados​

@ParameterizedTest com @ValueSource​

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;

@ParameterizedTest
@ValueSource(strings = {"John", "Jane", "Bob"})
void shouldAcceptValidNames(String name) {
    assertTrue(validator.isValidName(name));
}

@ParameterizedTest
@ValueSource(ints = {1, 2, 3, 4, 5})
void shouldBePositive(int number) {
    assertTrue(number > 0);
}

@CsvSource​

@ParameterizedTest
@CsvSource({
    "1, 1, 2",
    "2, 3, 5",
    "10, 20, 30",
    "-1, 1, 0"
})
void shouldAddNumbers(int a, int b, int expected) {
    assertEquals(expected, calculator.add(a, b));
}

@ParameterizedTest
@CsvSource({
    "john@email.com, true",
    "invalid-email, false",
    "test@domain.org, true",
    "'', false"
})
void shouldValidateEmail(String email, boolean expected) {
    assertEquals(expected, validator.isValidEmail(email));
}

@MethodSource​

@ParameterizedTest
@MethodSource("provideUsers")
void shouldValidateUser(User user, boolean expectedValid) {
    assertEquals(expectedValid, validator.isValid(user));
}

static Stream<Arguments> provideUsers() {
    return Stream.of(
        Arguments.of(new User("John", 25), true),
        Arguments.of(new User("", 25), false),
        Arguments.of(new User("Jane", -1), false),
        Arguments.of(new User("Bob", 18), true)
    );
}

@EnumSource​

@ParameterizedTest
@EnumSource(Status.class)
void shouldHandleAllStatuses(Status status) {
    assertDoesNotThrow(() -> processor.process(status));
}

@ParameterizedTest
@EnumSource(value = Status.class, names = {"ACTIVE", "PENDING"})
void shouldHandleActiveStatuses(Status status) {
    assertTrue(status == Status.ACTIVE || status == Status.PENDING);
}

6. Testes Condicionais​

@EnabledOnOs / @DisabledOnOs​

@Test
@EnabledOnOs(OS.WINDOWS)
void windowsOnlyTest() {
    // Executa apenas no Windows
}

@Test
@DisabledOnOs(OS.MAC)
void notOnMacTest() {
    // Não executa no Mac
}

@EnabledIfEnvironmentVariable​

@Test
@EnabledIfEnvironmentVariable(named = "ENV", matches = "dev")
void onlyInDevEnvironment() {
    // Executa apenas se ENV=dev
}

@EnabledIf​

@Test
@EnabledIf("customCondition")
void conditionalTest() {
    // ...
}

boolean customCondition() {
    return LocalTime.now().getHour() < 12;  // Somente de manhã
}

7. Testes Aninhados​

@Nested​

class UserServiceTest {

    @Nested
    @DisplayName("Ao criar um usuário")
    class CreateUser {
        
        @Test
        @DisplayName("deve ter sucesso com dados válidos")
        void shouldSucceedWithValidData() {
            User user = userService.create("John", "john@email.com");
            assertNotNull(user.getId());
        }
        
        @Test
        @DisplayName("deve falhar com nome vazio")
        void shouldFailWithEmptyName() {
            assertThrows(ValidationException.class, 
                () -> userService.create("", "john@email.com"));
        }
    }
    
    @Nested
    @DisplayName("Ao deletar um usuário")
    class DeleteUser {
        
        @Test
        @DisplayName("deve remover do banco de dados")
        void shouldRemoveFromDatabase() {
            userService.delete(1L);
            assertFalse(userService.exists(1L));
        }
    }
}

Exibição na IDE​

UserServiceTest
├── Ao criar um usuário
│   ├── ✓ deve ter sucesso com dados válidos
│   └── ✓ deve falhar com nome vazio
└── Ao deletar um usuário
    └── ✓ deve remover do banco de dados

8. Timeouts​

@Timeout​

@Test
@Timeout(5)  // Falha se passar de 5 segundos
void shouldCompleteQuickly() {
    // ...
}

@Test
@Timeout(value = 500, unit = TimeUnit.MILLISECONDS)
void shouldCompleteVeryQuickly() {
    // ...
}

assertTimeout​

@Test
void shouldCompleteInTime() {
    assertTimeout(Duration.ofSeconds(2), () -> {
        // Código que deve executar em menos de 2s
        Thread.sleep(1000);
    });
}

9. AssertJ (Recomendado)​

AssertJ oferece uma sintaxe mais fluida e legível:

import static org.assertj.core.api.Assertions.*;

@Test
void demonstrateAssertJ() {
    // Strings
    assertThat("Hello World")
        .startsWith("Hello")
        .endsWith("World")
        .contains("lo Wo")
        .hasSize(11);
    
    // Números
    assertThat(42)
        .isPositive()
        .isGreaterThan(40)
        .isBetween(40, 50);
    
    // Coleções
    assertThat(List.of("a", "b", "c"))
        .hasSize(3)
        .contains("a", "b")
        .doesNotContain("d")
        .containsExactly("a", "b", "c");
    
    // Objetos
    assertThat(user)
        .isNotNull()
        .hasFieldOrPropertyWithValue("name", "John")
        .extracting(User::getEmail)
        .isEqualTo("john@email.com");
    
    // Exceções
    assertThatThrownBy(() -> service.riskyMethod())
        .isInstanceOf(RuntimeException.class)
        .hasMessageContaining("error");
}

10. Resumo​

Anotações-Chave​

AnnotationDescrição
@TestMarca um método de teste
@BeforeEachAntes de cada teste
@AfterEachDepois de cada teste
@BeforeAllAntes de todos os testes (static)
@AfterAllDepois de todos os testes (static)
@DisplayNameNome legível para o teste
@DisabledDesativa o teste
@ParameterizedTestTeste com múltiplos valores
@NestedGrupo de testes aninhados

Asserções Essenciais​

assertEquals(expected, actual);
assertTrue(condition);
assertFalse(condition);
assertNull(value);
assertNotNull(value);
assertThrows(Exception.class, () -> ...);
assertAll("group", () -> ..., () -> ...);

Padrão de Teste​

@Test
void should_ExpectedBehavior_When_Condition() {
    // Arrange
    // ...
    
    // Act
    // ...
    
    // Assert
    // ...
}

🎯 Próximo Passo​

JUnit 5 permite escrever testes, mas como testar uma classe que depende de outras classes? É aí que entra o Mockito.

➡️ Capítulo 3: Mocking com Mockito

⬅️ Voltar ao Módulo 9