Quiz: Tests Spring Boot

Testez vos connaissances sur JUnit 5, Mockito et les tests d'intégration.

30 questions - Cliquez sur chaque question pour révéler la réponse.

Questions 1-10: JUnit 5

Question 1: Quelles sont les annotations de base JUnit 5?

Réponse:

Annotation	Description
`@Test`	Marque une méthode de test
`@BeforeEach`	Avant chaque test
`@AfterEach`	Après chaque test
`@BeforeAll`	Avant tous les tests (static)
`@AfterAll`	Après tous les tests (static)
`@Disabled`	Désactive un test
`@DisplayName`	Nom lisible

Question 2: Comment structurer un test avec le pattern AAA?

Réponse: 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);
}

Question 3: Quelles assertions utiliser avec AssertJ?

Réponse:

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);

Question 4: Comment tester une exception?

Réponse:

// 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");
}

Question 5: Comment exécuter un test plusieurs fois avec des paramètres différents?

Réponse:

@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));
}

Question 6: Comment grouper les tests?

Réponse:

@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() { }
}

Question 7: Comment désactiver un test conditionnellement?

Réponse:

@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;
}

Question 8: Comment donner un timeout à un test?

Réponse:

@Test
@Timeout(value = 5, unit = TimeUnit.SECONDS)
void shouldCompleteInTime() {
    // Test qui doit finir en moins de 5 secondes
}

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

Question 9: Comment réutiliser la configuration entre tests?

Réponse:

// Classe de base
abstract class BaseTest {
    
    @BeforeEach
    void commonSetup() {
        // Configuration commune
    }
}

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

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

Question 10: Comment exécuter les tests dans un ordre précis?

Réponse:

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

Note: évitez si possible les tests dépendants!

Questions 11-20: Mockito

Question 11: Comment créer un mock avec Mockito?

Réponse:

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

Question 12: Comment définir le comportement d'un mock?

Réponse:

// Retourner une valeur
when(userRepository.findById(1L)).thenReturn(Optional.of(user));

// Lancer une exception
when(userRepository.findById(999L)).thenThrow(new NotFoundException());

// Réponse dynamique
when(userRepository.save(any(User.class))).thenAnswer(invocation -> {
    User u = invocation.getArgument(0);
    u.setId(1L);
    return u;
});

Question 13: Comment vérifier qu'une méthode a été appelée?

Réponse:

// Vérifier l'appel
verify(userRepository).save(any(User.class));

// Vérifier le nombre d'appels
verify(userRepository, times(2)).findById(anyLong());
verify(userRepository, never()).delete(any());
verify(userRepository, atLeast(1)).findAll();

Question 14: Quelle est la différence entre @Mock et @Spy?

Réponse:

@Mock: crée un faux objet, toutes les méthodes retournent null/0/false
@Spy: utilise le vrai objet, peut surcharger certaines méthodes

@Spy
private UserService userService = new UserService();

// Seule cette méthode est mockée
doReturn(user).when(userService).findById(1L);

// Les autres méthodes exécutent le vrai code

Question 15: Comment capturer les arguments passés à un mock?

Réponse:

@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");
}

Question 16: Comment mocker une méthode void?

Réponse:

// Ne rien faire (défaut)
doNothing().when(emailService).sendEmail(any());

// Lancer une exception
doThrow(new MailException()).when(emailService).sendEmail(any());

// Exécuter du code
doAnswer(invocation -> {
    String email = invocation.getArgument(0);
    log.info("Would send email to: {}", email);
    return null;
}).when(emailService).sendEmail(any());

Question 17: Comment mocker des méthodes statiques?

Réponse:

@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);
        
        // Test
        String id = service.generateId();
        assertThat(id).contains("123e4567");
    }
}

Question 18: Comment vérifier l'ordre des appels?

Réponse:

@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());
}

Question 19: Comment utiliser les matchers Mockito?

Réponse:

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
));

Question 20: Comment réinitialiser un mock entre les tests?

Réponse:

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

// Ou pour un mock spécifique
Mockito.clearInvocations(userRepository);

Questions 21-30: Tests d'Intégration

Question 21: Quelle annotation pour un test d'intégration Spring Boot?

Réponse:

@SpringBootTest
class IntegrationTest {
    // Charge tout le contexte Spring
}

// Avec serveur web
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class WebIntegrationTest { }

Question 22: Comment tester uniquement la couche web?

Réponse:

@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"));
    }
}

Question 23: Comment tester uniquement la couche repository?

Réponse:

@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();
    }
}

Question 24: Comment utiliser TestRestTemplate?

Réponse:

@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);
    }
}

Question 25: Comment utiliser une base de données de test?

Réponse:

// H2 en mémoire (automatique avec @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);
    }
}

Question 26: Comment tester avec un profil spécifique?

Réponse:

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

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

Question 27: Comment tester la sécurité?

Réponse:

@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());
    }
}

Question 28: Comment tester les validations?

Réponse:

@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());
}

Question 29: Comment mesurer la couverture de code?

Réponse: Avec 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>

Rapport dans target/site/jacoco/index.html

Question 30: Quelles sont les bonnes pratiques de test?

Réponse:

Un test = un comportement: pas de multi-assertions complexes
Tests indépendants: pas de dépendances entre tests
Noms descriptifs: shouldReturnUserWhenValidId
Données isolées: chaque test prépare ses données
Mocker les dépendances externes: API, email, etc.
Éviter les tests flaky: pas de dépendances au temps
Tester les cas d'erreur: pas seulement le happy path
Couverture raisonnable: viser 70-80%, pas 100%

Score

Score	Niveau
27-30	Excellent - Tests maîtrisés
21-26	Bien - Quelques révisions
15-20	Moyen - Relisez les chapitres
Moins de 15	À revoir

Retour au Module 9

Questions 1-10: JUnit 5​

Questions 11-20: Mockito​

Questions 21-30: Tests d'Intégration​

Score​

Questions 1-10: JUnit 5

Questions 11-20: Mockito

Questions 21-30: Tests d'Intégration

Score