Simulation (stubbing) de spies et gestion des exceptions
Dans cette étape, nous apprendrons à configurer (stub) un spy pour remplacer son comportement par défaut et à gérer les exceptions qui peuvent survenir lors de l'utilisation de Mockito.
Configuration (Stubbing) d'un spy
Les spies utilisent les méthodes des objets réels par défaut, mais parfois, nous souhaitons changer ce comportement à des fins de test. Cela s'appelle "configurer (stub)" le spy. Ajoutons une méthode de test qui montre comment configurer un spy :
@Test
public void testStubbingSpy() {
// Create a spy of ArrayList
ArrayList<Integer> spyList = Mockito.spy(new ArrayList<>());
// Add an element
spyList.add(5);
// Verify the element was added
Mockito.verify(spyList).add(5);
// By default, contains() should return true for element 5
assertTrue(spyList.contains(5));
System.out.println("Stubbing Example - Default behavior: spyList.contains(5) = " + spyList.contains(5));
// Stub the contains() method to always return false for the value 5
Mockito.doReturn(false).when(spyList).contains(5);
// Now contains() should return false, even though the element is in the list
assertFalse(spyList.contains(5));
System.out.println("Stubbing Example - After stubbing: spyList.contains(5) = " + spyList.contains(5));
// The element is still in the list (stubbing didn't change the list content)
assertEquals(1, spyList.size());
assertEquals(Integer.valueOf(5), spyList.get(0));
System.out.println("Stubbing Example - Spy List Content: " + spyList);
}
Note importante sur la configuration (stubbing)
Lors de la configuration des méthodes d'un spy, il est recommandé d'utiliser doReturn(), doThrow(), doAnswer(), etc., au lieu de when(). En effet, avec les spies, la syntaxe when().thenReturn() peut appeler la méthode réelle lors de la configuration, ce qui peut entraîner des effets secondaires inattendus.
Par exemple :
// This might call the real get() method, causing issues if index 10 doesn't exist
Mockito.when(spyList.get(10)).thenReturn(99); // May throw IndexOutOfBoundsException
// This is the correct way to stub a spy
Mockito.doReturn(99).when(spyList).get(10); // Safe, doesn't call the real method
Gestion de l'exception NotAMockException
Si vous essayez d'utiliser les méthodes de vérification de Mockito sur un objet normal (pas un mock ou un spy), vous obtiendrez une NotAMockException. Ajoutons une méthode de test pour démontrer cette exception :
@Test
public void testNotAMockException() {
try {
// Create a regular ArrayList (not a mock or spy)
ArrayList<Integer> regularList = new ArrayList<>();
regularList.add(5);
// Try to verify an interaction on a regular object
Mockito.verify(regularList).add(5);
fail("Expected NotAMockException was not thrown");
} catch (NotAMockException e) {
// Expected exception
System.out.println("NotAMockException Example - Caught expected exception: " + e.getMessage());
assertTrue(e.getMessage().contains("Argument passed to verify() is not a mock"));
}
}
Compilons notre code mis à jour :
cd ~/project
javac -cp lib/junit.jar:lib/mockito-core.jar:lib/byte-buddy.jar:lib/byte-buddy-agent.jar:lib/objenesis.jar:lib/hamcrest-core.jar MockitoSpyDemo.java
Le code devrait compiler sans erreur. Dans cette étape, nous avons appris à configurer les méthodes des spies pour remplacer leur comportement par défaut et à gérer l'exception NotAMockException qui se produit lorsque nous utilisons les méthodes de vérification sur des objets normaux.
Dans l'étape suivante, nous comparerons les mocks et les spies pour comprendre leurs principales différences.
