Spring Boot — Tests unitaires avec Mockito

// STUB — retourne une valeur programmée
when(repo.findById("S1")).thenReturn(Optional.of(stock));

// MOCK — stub + vérification d'appel
verify(repo).findById("S1");

// FAKE — implémentation simplifiée réelle (sans Mockito)
class FakeRepo implements StockRepository {
    Map<String, Stock> map = new HashMap<>();
    public Optional<Stock> findById(String id) {
        return Optional.ofNullable(map.get(id));
    }
}

// SPY — enveloppe un vrai objet
List<String> spyList = spy(new ArrayList<>());
spyList.add("A");
verify(spyList).add("A"); // enregistré ✓
assertEquals(1, spyList.size()); // vraie méthode exécutée ✓

@ExtendWith(MockitoExtension.class)   // ✓ active Mockito pour JUnit 5
class StockServiceTest {

    @Mock
    StockRepository repo;              // ✓ équivalent mock(StockRepository.class)

    @InjectMocks
    StockService service;              // ✓ équivalent new StockService(repo)

    @Captor
    ArgumentCaptor<Stock> captor;
}

// Code testé
public void save(String id) {
    Stock stock = new Stock(id, UUID.randomUUID(), Instant.now());
    repo.save(stock);
}

// Test
@Test
void shouldSaveWithCorrectId() {
    service.save("S1");

    verify(repo).save(captor.capture());     // ✓ capture l'argument réel
    Stock saved = captor.getValue();

    assertThat(saved.getId()).isEqualTo("S1");
    assertNotNull(saved.getCreatedAt());     // ✓ inspecte les champs dynamiques
}

verify(repo).save(stock);                   // appelé exactement 1 fois (défaut)
verify(repo, times(3)).save(stock);         // exactement 3 fois
verify(repo, never()).save(stock);          // jamais appelé
verify(repo, atLeast(1)).save(stock);       // >= 1 fois

verifyNoInteractions(repo);                 // aucun appel sur ce mock
verifyNoMoreInteractions(repo);             // aucun appel non encore vérifié

// Valeur directe — quand la valeur exacte est connue
verify(repo).findById("S1");

// eq() — pour mixer avec d'autres matchers
verify(repo).find(eq("P1"), anyInt());

// any() / anyString() / anyInt()
verify(repo).save(any(Stock.class));

// argThat() — condition métier
verify(repo).save(argThat(s -> s.getQuantity().compareTo(BigDecimal.ZERO) > 0));

// ✓ Sur un MOCK pur — when() est safe
@Mock StockRepository repo;
when(repo.findById("S1")).thenReturn(Optional.of(stock));

// ✓ Sur un SPY — doReturn() OBLIGATOIRE
StockService spy = spy(new StockService(repo));
doReturn(BigDecimal.TEN)
    .when(spy)
    .computeQuantity(any());    // ✓ la vraie méthode n'est PAS appelée

// assertThrows — tester qu'une exception est lancée
when(repo.findById("S1")).thenReturn(Optional.empty());

RuntimeException ex = assertThrows(
    RuntimeException.class,
    () -> service.find("S1")
);
assertEquals("Stock not found", ex.getMessage());
verify(repo, never()).delete(any()); // ✓ vérifier qu'aucune suite n'a eu lieu

// thenThrow — méthode avec retour
when(repo.findById("S1")).thenThrow(new RuntimeException("DB error"));

// doThrow — méthode void
doThrow(new RuntimeException("DB error")).when(repo).save(any());

// Comportements enchaînés
when(repo.findById("S1"))
    .thenThrow(new RuntimeException())
    .thenReturn(Optional.of(stock)); // 1er appel → exception, 2ème → stock