La gestion des exceptions et les doublures de test
La gestion des exceptions et les doublures de test
Programmation, Tests unitaires, JUnit · course
Fiche de révisionFiche de cours
Rédigée à partir de ce document, puis vérifiée avant publication.
Ce document présente les notions essentielles sur la gestion des exceptions et les doublures de test, destinées aux étudiants et développeurs souhaitant approfondir leurs compétences en tests unitaires, notamment en Java avec JUnit et Mockito. Il couvre les différentes méthodes pour gérer les exceptions dans les tests, les types de doublures de test, ainsi que les bonnes pratiques pour écrire des tests efficaces.
La gestion des exceptions dans les tests unitaires est une étape cruciale pour s'assurer que le code réagit correctement aux erreurs. En Java, plusieurs méthodes existent pour tester les exceptions levées par une méthode.
@Test de JUnit en spécifiant la classe d'exception attendue :@Test(expected = Exception.class)
Cette méthode repose sur les assertions et permet de vérifier que l'exception spécifiée est levée lors du test. Cependant, elle présente une limitation : le test passe si n'importe quelle instruction lève l'exception, sans garantir que c'est bien l'instruction attendue.
Une autre approche consiste à utiliser un bloc try...catch dans le test. On appelle la méthode censée lever l'exception dans le bloc try. Si aucune exception n'est levée, on appelle la méthode fail() pour indiquer que le test a échoué. Dans le bloc catch, on peut alors vérifier le message de l'exception à l'aide d'assertions comme assertThat (disponible depuis JUnit 4.4).
JUnit propose également une méthode basée sur les règles (Rules) qui permet de spécifier plus finement l'exception attendue et son message. Cette méthode utilise des objets Matchers issus de la librairie Hamcrest, intégrée dans JUnit 4.4 et supérieur. Elle offre plus de contrôle que l'annotation @Test(expected=...).
Une doublure de test est un objet qui remplace un objet réel pour faciliter le test d'une unité de code. Elle permet de reproduire l'état ou le comportement d'un objet dont dépend la partie testée.
Exemple : pour tester une voiture, on peut utiliser une doublure de moteur simulant l'avance ou le recul.
Les doublures peuvent être créées manuellement ou générées automatiquement avec des outils comme Mockito ou EasyMock.
Un dummy peut être une instance d'une interface métier passée en paramètre mais qui ne sera jamais utilisée dans le test. Par exemple :
interface Service {
void execute();
}
class DummyService implements Service {
public void execute() {
// Ne fait rien
}
}
Un stub fournit une réponse fixe. Par exemple, une méthode d'authentification qui renvoie toujours true :
class AuthStub {
public boolean authenticate(String user, String pass) {
return true; // réponse prédéfinie
}
}
Un spy permet de vérifier le comportement, par exemple le nombre d'appels :
class AuthSpy extends AuthStub {
private int callCount = 0;
@Override
public boolean authenticate(String user, String pass) {
callCount++;
return super.authenticate(user, pass);
}
public int getCallCount() {
return callCount;
}
}
Un mock est un spy avec des attentes précises sur les appels. Par exemple, on peut vérifier que la méthode authorize a été appelée :
Mock<Auth> mockAuth = mock(Auth.class);
when(mockAuth.authorize(anyString())).thenReturn(true);
// exécution du test
verify(mockAuth).authorize("user");
Un fake est une implémentation simplifiée mais fonctionnelle, par exemple une base de données en mémoire :
class FakeDatabase {
private Map<String, String> data = new HashMap<>();
public void save(String key, String value) {
data.put(key, value);
}
public String find(String key) {
return data.get(key);
}
}Mockito est un framework populaire pour créer des doublures en Java. Il permet de créer des mocks, stubs et spies facilement.
Deux façons principales :
mock()Avec Mockito, on utilise le mot-clé when pour définir les comportements :
when(...).thenReturn(...) : pour retourner une valeurwhen(...).thenThrow(...) : pour lever une exceptionMockito permet aussi de créer des spies, qui sont des objets réels surveillés.
Pour vérifier les arguments passés aux méthodes, Mockito utilise la méthode equals() par défaut, mais on peut utiliser des matchers pour ignorer la valeur exacte :
anyInt(), anyString(), any(), etc.Attention : si un matcher est utilisé dans une expression, tous les arguments doivent être des matchers.
verifyLa méthode verify permet de vérifier que certaines méthodes ont été appelées, avec les bons arguments. Si la vérification échoue, une exception est levée et le test échoue.
doXXX pour les méthodes voiddoThrow : pour simuler une exceptiondoNothing : pour ne rien fairedoReturn : pour retourner une valeurdoAnswer : pour fournir une réponse dynamique en fonction des paramètresPlusieurs critères permettent de définir ce qu'il faut tester, regroupés sous les acronymes Right-BICEP et CORRECT.
Le patron AAA est une méthode standard pour écrire des tests unitaires clairs et structurés :