Lancer des exceptions nécessite également des tests unitaires. Dans JUnit 5, des méthodes pour tester ces exceptions ont été ajoutées. La logique derrière elles est simple :

"s'il est prévu qu'une exception sera lancée mais qu'elle ne l'est pas, alors la méthode ne fonctionne pas correctement, et le test échouera."

Inversement, "s'il est prévu qu'aucune exception ne sera lancée mais que la méthode en lance une, alors la méthode ne fonctionne pas correctement, et le test échouera également."

Considérons ces deux assertions utilisées pour tester le lancement d'exceptions : assertThrows() et assertDoesNotThrow():

`assertThrows()`

Comme son nom l'indique, cette méthode va tester si une exception est lancée, en s'attendant à ce qu'une exception soit lancée.
Cela se fait en utilisant une expression lambda. Par exemple, testons le lancement d'une NullPointerException lors de l'utilisation de la méthode sur une chaîne null :

Comme vous pouvez le voir, nous créons une variable avec le type String et une valeur de null, puis nous testons le lancement d'une exception lors de l'appel de la méthode .length() sur cette variable. Lorsque vous appelez des méthodes sur une String avec une valeur null, une NullPointerException est lancée.
Dans l'assertion assertThrows, nous spécifions la classe de l'exception que nous attendons, qui dans notre cas est NullPointerException.class. Ensuite, en utilisant une expression lambda, nous spécifions dans quelle condition cette exception devrait être lancée. La syntaxe est simple :

En d'autres termes :

Nous nous attendons à ce qu'une NullPointerException soit levée lors de l'appel de la méthode .length() sur l'objet str, dont la valeur est null.

Il est également important de noter que l'assertion assertThrows() retourne l'exception qui a été capturée et testée. Cela signifie que nous pouvons initialiser une variable, exception, en utilisant cette méthode et l'utiliser ensuite.
Par exemple :

Meilleures Pratiques

1. Tester une exception par test : Chaque méthode de test devrait idéalement tester une seule exception spécifique. Cela rend vos tests plus maintenables et leur intention plus claire ;

2. Tester les détails de l'exception : Chaque fois que possible, testez non seulement le type de l'exception mais aussi son message ou d'autres propriétés. Cela garantit que la bonne exception est lancée pour la bonne raison ;

3. Utiliser les dernières fonctionnalités : Si vous utilisez JUnit 5, préférez l'approche assertThrows pour sa flexibilité et sa clarté. Elle permet non seulement de vérifier le type de l'exception lancée mais aussi de réaliser d'autres assertions sur l'objet exception.

`assertDoesNotThrow()`

Parfois, nous devons tester une méthode qui lance une exception, mais dans notre cas, elle ne devrait pas. Cela se fait en utilisant l'assertion 'assertDoesNotThrow()'. L'algorithme ici est le même qu'avec l'assertion 'assertThrows()', sauf que nous ne spécifions pas l'exception que nous nous attendons à recevoir ( car nous ne nous attendons pas à la recevoir ).

La syntaxe ressemblera à ceci :

Comme vous pouvez le voir dans ce test, nous vérifions que la méthode .length() ne lance pas d'exception lorsqu'elle est appelée sur un objet non nul. Ensuite, nous vérifions que la méthode exécute correctement sa fonction et retourne le bon résultat. Comme vous pouvez le voir, nous n'utilisons pas de classe d'exception dans les paramètres car nous ne nous attendons à aucune exception.

Tout cela semble simple. Dans le prochain chapitre, voyons comment vous gérez l'écriture de tels tests par vous-même!