Quiz: Testes Spring Boot

Teste seus conhecimentos sobre JUnit 5, Mockito e testes de integração.

30 questões - Clique em cada pergunta para revelar a resposta.

Questões 1-10: JUnit 5

Questão 1: Quais são as anotações básicas do JUnit 5?

Resposta:

Anotação	Descrição
`@Test`	Marca um método de teste
`@BeforeEach`	Antes de cada teste
`@AfterEach`	Após cada teste
`@BeforeAll`	Antes de todos os testes (static)
`@AfterAll`	Após todos os testes (static)
`@Disabled`	Desativa um teste
`@DisplayName`	Nome legível

Questão 2: Como estruturar um teste com o padrão AAA?

Resposta: Arrange-Act-Assert:

@Test
void shouldCalculateTotal() {
    // Arrange (Given)
    Order order = new Order();
    order.addItem(new Item("Book", 10.0));
    order.addItem(new Item("Pen", 2.0));
    
    // Act (When)
    double total = order.calculateTotal();
    
    // Assert (Then)
    assertEquals(12.0, total);
}

Questão 3: Quais asserções usar com AssertJ?

Resposta:

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

assertThat(result).isEqualTo(expected);
assertThat(list).hasSize(3);
assertThat(list).contains("item");
assertThat(user.getName()).isNotBlank();
assertThat(price).isGreaterThan(0);
assertThatThrownBy(() -> service.process(null))
    .isInstanceOf(IllegalArgumentException.class);

Questão 4: Como testar uma exceção?

Resposta:

// JUnit 5
@Test
void shouldThrowException() {
    assertThrows(IllegalArgumentException.class, () -> {
        service.process(null);
    });
}

// AssertJ
@Test
void shouldThrowException() {
    assertThatThrownBy(() -> service.process(null))
        .isInstanceOf(IllegalArgumentException.class)
        .hasMessageContaining("cannot be null");
}

Questão 5: Como executar um teste várias vezes com parâmetros diferentes?

Resposta:

@ParameterizedTest
@ValueSource(strings = {"a@b.com", "test@domain.org"})
void shouldValidateEmail(String email) {
    assertTrue(validator.isValidEmail(email));
}

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

Questão 6: Como agrupar testes?

Resposta:

@Nested
@DisplayName("When user is logged in")
class WhenLoggedIn {
    
    @BeforeEach
    void setup() {
        login();
    }
    
    @Test
    void canAccessProfile() { }
    
    @Test
    void canLogout() { }
}

@Nested
@DisplayName("When user is anonymous")
class WhenAnonymous {
    
    @Test
    void cannotAccessProfile() { }
}

Questão 7: Como desabilitar um teste condicionalmente?

Resposta:

@Test
@EnabledOnOs(OS.LINUX)
void onlyOnLinux() { }

@Test
@EnabledIfEnvironmentVariable(named = "ENV", matches = "CI")
void onlyInCI() { }

@Test
@DisabledIf("isWeekend")
void notOnWeekend() { }

boolean isWeekend() {
    return LocalDate.now().getDayOfWeek().getValue() > 5;
}

Questão 8: Como definir um timeout para um teste?

Resposta:

@Test
@Timeout(value = 5, unit = TimeUnit.SECONDS)
void shouldCompleteInTime() {
    // Teste que deve terminar em menos de 5 segundos
}

// Ou com assertTimeout
@Test
void shouldCompleteInTime() {
    assertTimeout(Duration.ofSeconds(2), () -> {
        service.longOperation();
    });
}

Questão 9: Como reutilizar configuração entre testes?

Resposta:

// Classe base
abstract class BaseTest {
    
    @BeforeEach
    void commonSetup() {
        // Configuração comum
    }
}

class UserServiceTest extends BaseTest {
    
    @Test
    void testUser() { }
}

// Ou com Extension
@ExtendWith(DatabaseExtension.class)
class DatabaseTest { }

Questão 10: Como executar os testes em uma ordem específica?

Resposta:

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
class OrderedTest {
    
    @Test
    @Order(1)
    void createUser() { }
    
    @Test
    @Order(2)
    void updateUser() { }
    
    @Test
    @Order(3)
    void deleteUser() { }
}

Nota: evite testes dependentes sempre que possível!

Questões 11-20: Mockito

Questão 11: Como criar um mock com Mockito?

Resposta:

@ExtendWith(MockitoExtension.class)
class UserServiceTest {
    
    @Mock
    private UserRepository userRepository;
    
    @InjectMocks
    private UserService userService;
    
    // Ou manualmente
    UserRepository repo = mock(UserRepository.class);
}

Questão 12: Como definir o comportamento de um mock?

Resposta:

// Retornar um valor
when(userRepository.findById(1L)).thenReturn(Optional.of(user));

// Lançar uma exceção
when(userRepository.findById(999L)).thenThrow(new NotFoundException());

// Resposta dinâmica
when(userRepository.save(any(User.class))).thenAnswer(invocation -> {
    User u = invocation.getArgument(0);
    u.setId(1L);
    return u;
});

Questão 13: Como verificar se um método foi chamado?

Resposta:

// Verificar chamada
verify(userRepository).save(any(User.class));

// Verificar número de chamadas
verify(userRepository, times(2)).findById(anyLong());
verify(userRepository, never()).delete(any());
verify(userRepository, atLeast(1)).findAll();

Questão 14: Qual a diferença entre @Mock e @Spy?

Resposta:

@Mock: cria um objeto falso, todos os métodos retornam null/0/false
@Spy: usa o objeto real, pode sobrescrever alguns métodos

@Spy
private UserService userService = new UserService();

// Apenas este método é mockado
doReturn(user).when(userService).findById(1L);

// Os outros métodos executam o código real

Questão 15: Como capturar os argumentos passados para um mock?

Resposta:

@Captor
ArgumentCaptor<User> userCaptor;

@Test
void shouldCaptureUser() {
    userService.createUser(request);
    
    verify(userRepository).save(userCaptor.capture());
    
    User savedUser = userCaptor.getValue();
    assertThat(savedUser.getEmail()).isEqualTo("test@example.com");
}

Questão 16: Como mockar um método void?

Resposta:

// Não faz nada (padrão)
doNothing().when(emailService).sendEmail(any());

// Lançar uma exceção
doThrow(new MailException()).when(emailService).sendEmail(any());

// Executar código
doAnswer(invocation -> {
    String email = invocation.getArgument(0);
    log.info("Would send email to: {}", email);
    return null;
}).when(emailService).sendEmail(any());

Questão 17: Como mockar métodos estáticos?

Resposta:

@Test
void testStaticMethod() {
    try (MockedStatic<UUID> mockedUUID = mockStatic(UUID.class)) {
        UUID fakeUUID = UUID.fromString("123e4567-e89b-12d3-a456-426614174000");
        mockedUUID.when(UUID::randomUUID).thenReturn(fakeUUID);
        
        // Teste
        String id = service.generateId();
        assertThat(id).contains("123e4567");
    }
}

Questão 18: Como verificar a ordem das chamadas?

Resposta:

@Test
void shouldCallInOrder() {
    service.process();
    
    InOrder inOrder = inOrder(validator, repository, notifier);
    
    inOrder.verify(validator).validate(any());
    inOrder.verify(repository).save(any());
    inOrder.verify(notifier).notify(any());
}

Questão 19: Como usar matchers do Mockito?

Resposta:

when(repo.findByName(anyString())).thenReturn(user);
when(repo.findByAge(eq(25))).thenReturn(users);
when(repo.search(argThat(s -> s.length() > 3))).thenReturn(results);

verify(repo).save(argThat(user -> 
    user.getEmail().contains("@") && user.getAge() > 18
));

Questão 20: Como reinicializar um mock entre os testes?

Resposta:

@AfterEach
void resetMocks() {
    reset(userRepository);
}

// Ou para um mock específico
Mockito.clearInvocations(userRepository);

Questões 21-30: Testes de Integração

Questão 21: Qual anotação para um teste de integração Spring Boot?

Resposta:

@SpringBootTest
class IntegrationTest {
    // Carrega todo o contexto Spring
}

// Com servidor web
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class WebIntegrationTest { }

Questão 22: Como testar apenas a camada web?

Resposta:

@WebMvcTest(UserController.class)
class UserControllerTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @MockBean
    private UserService userService;
    
    @Test
    void shouldReturnUser() throws Exception {
        when(userService.findById(1L)).thenReturn(user);
        
        mockMvc.perform(get("/api/users/1"))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$.name").value("John"));
    }
}

Questão 23: Como testar apenas a camada repository?

Resposta:

@DataJpaTest
class UserRepositoryTest {
    
    @Autowired
    private TestEntityManager entityManager;
    
    @Autowired
    private UserRepository userRepository;
    
    @Test
    void shouldFindByEmail() {
        User user = new User("test@example.com");
        entityManager.persist(user);
        entityManager.flush();
        
        Optional<User> found = userRepository.findByEmail("test@example.com");
        
        assertThat(found).isPresent();
    }
}

Questão 24: Como usar TestRestTemplate?

Resposta:

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class ApiIntegrationTest {
    
    @Autowired
    private TestRestTemplate restTemplate;
    
    @Test
    void shouldCreateUser() {
        UserRequest request = new UserRequest("test@example.com");
        
        ResponseEntity<User> response = restTemplate.postForEntity(
            "/api/users", request, User.class);
        
        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED);
    }
}

Questão 25: Como usar um banco de dados de teste?

Resposta:

// H2 em memória (automático com @DataJpaTest)

// Ou Testcontainers
@Testcontainers
@SpringBootTest
class PostgresIntegrationTest {
    
    @Container
    static PostgreSQLContainer<?> postgres = 
        new PostgreSQLContainer<>("postgres:15");
    
    @DynamicPropertySource
    static void configureProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url", postgres::getJdbcUrl);
        registry.add("spring.datasource.username", postgres::getUsername);
        registry.add("spring.datasource.password", postgres::getPassword);
    }
}

Questão 26: Como testar com um perfil específico?

Resposta:

@SpringBootTest
@ActiveProfiles("test")
class TestProfileTest {
    // Usa application-test.yml
}

# application-test.yml
spring:
  datasource:
    url: jdbc:h2:mem:testdb

Questão 27: Como testar a segurança?

Resposta:

@WebMvcTest(SecuredController.class)
@Import(SecurityConfig.class)
class SecurityTest {
    
    @Test
    void anonymousCannotAccess() throws Exception {
        mockMvc.perform(get("/api/admin"))
            .andExpect(status().isUnauthorized());
    }
    
    @Test
    @WithMockUser(roles = "ADMIN")
    void adminCanAccess() throws Exception {
        mockMvc.perform(get("/api/admin"))
            .andExpect(status().isOk());
    }
}

Questão 28: Como testar validações?

Resposta:

@Test
void shouldRejectInvalidEmail() throws Exception {
    String invalidRequest = """
        {"email": "not-an-email", "name": "John"}
        """;
    
    mockMvc.perform(post("/api/users")
            .contentType(MediaType.APPLICATION_JSON)
            .content(invalidRequest))
        .andExpect(status().isBadRequest())
        .andExpect(jsonPath("$.errors.email").exists());
}

Questão 29: Como medir a cobertura de código?

Resposta: Com JaCoCo:

<plugin>
    <groupId>org.jacoco</groupId>
    <artifactId>jacoco-maven-plugin</artifactId>
    <version>0.8.11</version>
    <executions>
        <execution>
            <goals>
                <goal>prepare-agent</goal>
            </goals>
        </execution>
        <execution>
            <id>report</id>
            <phase>test</phase>
            <goals>
                <goal>report</goal>
            </goals>
        </execution>
    </executions>
</plugin>

Relatório em target/site/jacoco/index.html

Questão 30: Quais são as boas práticas de teste?

Resposta:

Um teste = um comportamento: evite múltiplas asserções complexas
Testes independentes: sem dependências entre testes
Nomes descritivos: shouldReturnUserWhenValidId
Dados isolados: cada teste prepara seus próprios dados
Mockar dependências externas: API, email, etc.
Evitar testes flaky: sem dependências de tempo
Testar casos de erro: não apenas o happy path
Cobertura razoável: busque 70-80%, não 100%

Pontuação

Pontuação	Nível
27-30	Excelente - Domina testes
21-26	Bom - Algumas revisões
15-20	Médio - Releia os capítulos
Menos de 15	Precisa revisar

Voltar ao Módulo 9

Questões 1-10: JUnit 5​

Questões 11-20: Mockito​

Questões 21-30: Testes de Integração​

Pontuação​

Questões 1-10: JUnit 5

Questões 11-20: Mockito

Questões 21-30: Testes de Integração

Pontuação