Écrire des tests unitaires en Java

Les tests sont une bonne pratique essentielle lors du développement de logiciels. Les tests unitaires font partie des nombreuses stratégies qui permettent de vérifier que notre code est fonctionnel et optimal. En tant que développeurs, nous pouvons écrire des tests unitaires pour vérifier des composants individuels (unités) du code de l’application, comme une méthode précise. L’idée consiste à écrire un ou plusieurs tests unitaires pour chaque partie du code et à les exécuter à chaque modification afin de détecter les défauts dès leur introduction dans la base de code. Pour du code nouveau, les tests doivent être ajoutés en même temps que le code (voire avant). Pour du code existant, si aucun test n’est déjà présent, il faut en ajouter afin de couvrir une grande partie — sinon la totalité — des chemins d’exécution de la logique de l’application.

Les tests unitaires visent à supprimer toutes les dépendances externes et à confirmer qu’un morceau de code précis se comporte comme prévu dans différentes situations. Il peut s’agir d’appeler plusieurs fois une méthode, chaque fois avec de nouveaux paramètres, et de vérifier qu’elle renvoie la valeur correcte, déclenche une exception ou exécute une tâche précise.

Parmi les frameworks de tests unitaires disponibles, de nombreux développeurs Java utilisent JUnit. Dans cet article, nous allons apprendre à installer et à utiliser JUnit 5 pour écrire des tests unitaires pour du code Java. Nous utiliserons l’environnement de développement intégré (IDE) VSCode pour écrire nos tests, et Java 11 avec Maven pour les exécuter. Toutefois, des outils comme Eclipse et IntelliJ fonctionnent de façon similaire et vous permettront de suivre les étapes.

Pour découvrir d’autres outils de vérification de votre code Java, consultez nos outils de revue de code Java ou notre article sur la sécurité en Java, qui vous apportera des connaissances de base supplémentaires.

Comment écrire votre premier test unitaire en Java

Dans cette section, nous allons installer le framework JUnit et écrire quelques tests unitaires. Nous exécuterons ensuite les tests sur ce projet de code exemple. Le projet est préconfiguré avec le code de l’application et un modèle de classe de test qui contient tout ce dont nous avons besoin pour commencer à ajouter des tests.

Avant de commencer à écrire nos tests, examinons le code d’exemple.

1package com.snyk.unittestdemo;
2
3public class App 
4{
5    public static void main( String[] args )
6    {
7        try {
8            System.out.println(generateUpdateUserFirstNameStatement("John", "abcdef1234567"));
9        }
10        catch (Error e){
11            e.printStackTrace();
12        }
13    }
14
15    public static String generateUpdateUserFirstNameStatement(String firstName, String userId) throws Error{
16        if(userId.contains(";") || firstName.contains(";")){
17            throw new Error("parameters may contain SQL injection");
18        }
19        return "UPDATE TABLE user SET first_name = '" + firstName + "' WHERE user_id = '" + userId +"';" ;
20    }
21
22}

Notre application comporte une méthode main qui appelle la méthode generateUpdateUserFirstNameStatement et affiche le résultat. Si l’appel à la méthode generateUpdateUserFirstNameStatement déclenche une erreur, l’application intercepte l’exception et affiche la trace de la pile.

La méthode generateUpdateUserFirstNameStatement est une méthode simple qui accepte deux paramètres de type chaîne de caractères et les utilise pour générer une instruction SQL UPDATE. Le code déclenche une erreur si l’un des paramètres contient un point-virgule, car cela peut indiquer une injection SQL dans l’entrée.

Cette méthode se prête parfaitement aux tests unitaires, car nous voulons vérifier son fonctionnement dans deux situations. D’abord, lorsque nous lui transmettons deux chaînes de caractères classiques en paramètres, nous nous attendons à obtenir une chaîne contenant l’instruction SQL. Ensuite, si nous fournissons en second paramètre une chaîne contenant une injection SQL, nous nous attendons à ce que la méthode déclenche une erreur. Un test unitaire nous permet de vérifier ces deux cas.

Pour commencer, nous devons installer quelques packages Maven, notamment le maven-surefire-plugin, qui comprend la bibliothèque JUnit. Nous devons également indiquer à Maven que notre application dépend de JUnit lors de l’exécution des tests.

Ouvrons le fichier pom.xml fourni et ajoutons le code de dépendance suivant dans la section correspondante, à la ligne 21.

1<dependency>
2  <groupId>junit</groupId>
3  <artifactId>junit</artifactId>
4  <version>4.11</version>
5  <scope>test</scope>
6</dependency>

Une fois cette étape terminée, enregistrez le fichier.

Nous pouvons maintenant utiliser Maven pour installer les packages. Pour ce faire dans VSCode, développez le menu Maven en bas à gauche, faites un clic droit sur le projet, puis cliquez sur install. Si vous utilisez un autre IDE, la procédure peut être différente.

Si vous ne savez pas comment procéder dans votre IDE, vous pouvez toujours installer les dépendances depuis la ligne de commande. Dans un terminal, accédez au répertoire racine de votre projet, puis exécutez la commande Maven suivante pour installer les dépendances.

Remarque : si Maven n’est pas installé sur votre machine, suivez les instructions d’installation avant d’exécuter cette commande.

1mvn install -f pom.xml

Une fois l’opération terminée, Maven aura installé les plugins indiqués dans notre fichier pom.xml file, notamment la bibliothèque JUnit. Lors de l’exécution des tests, Maven sait qu’il doit utiliser JUnit, que nous avons défini comme dépendance de test à l’aide de <scope>test</scope> dans la configuration.

Comme le montre le résultat ci-dessus, la fin de l’installation affiche les informations relatives aux tests. Toutefois, aucun test n’est configuré pour le moment : le nombre de tests exécutés est donc de 0. Ajoutons deux tests unitaires à notre application.

Pour commencer, ouvrez le fichier src/test/java/com/snyk/unittestdemo/AppTest.java, que Maven exécutera pour lancer nos tests. Nous devons d’abord importer les packages JUnit nécessaires. Ajoutez les deux imports suivants au début du fichier :

1import org.junit.Test;
2
3import static org.junit.Assert.assertTrue;

Le premier import nous donne accès à l’annotation de test JUnit, qui nous permet de définir nos méthodes comme des tests. Le second importe la méthode assertTrue fournie par JUnit. Nous l’utilisons pour vérifier si une condition est vraie. Si c’est le cas, le test réussit. Sinon, il échoue.

Ajoutons notre premier test. Il vérifiera que notre méthode generateUpdateUserFirstNameStatement renvoie le résultat correct lorsqu’elle reçoit deux chaînes de caractères classiques. Dans la classe AppTest, ajoutez la méthode suivante.

1@Test
2public void shouldGenerateUpdateStatement()
3{
4    String actual = App.generateUpdateUserFirstNameStatement("John", "abcdef1234567");
5    String expected = "UPDATE TABLE user SET first_name = 'John' WHERE user_id = 'abcdef1234567';";
6    assertTrue( actual.equals(expected) );
7}

Nous avons défini la méthode comme un test à l’aide de l’annotation @Test. Nous avons ensuite utilisé la méthode importée assertTrue pour vérifier le résultat de notre méthode generateUpdateUserFirstNameStatement. Nous lui avons fourni deux chaînes de caractères — John et abcdef1234567 — et voulons vérifier que la fonction renvoie la chaîne attendue. Si notre méthode fonctionne correctement, ce test devrait réussir.

Enregistrez le fichier et exécutez le test pour vérifier qu’il réussit. Dans VSCode, vous pouvez faire un clic droit sur le projet Maven et cliquer sur test.

Vous pouvez également exécuter cette commande depuis le terminal. Pour cela, ouvrez le terminal, accédez au dossier du projet, puis exécutez la commande suivante.

1mvn test -f pom.xml

Cette commande demande à Maven de compiler l’application et d’exécuter les tests. Le résultat des tests devrait maintenant indiquer qu’un test a été exécuté et qu’aucun échec n’a été constaté.

Modifions maintenant légèrement la méthode generateUpdateUserFirstNameStatement, en changeant l’instruction UPDATE renvoyée par la fonction. Relancez les tests pour voir comment Maven signale un échec.

Le résultat change et nous indique maintenant qu’un test a échoué. Sous l’en-tête Results:, vous pouvez voir le nombre et le type des échecs. Dans ce cas, le résultat précise le nom de notre méthode de test generateUpdateUserFirstNameStatement ainsi que le numéro de la ligne où le test a échoué (ligne 14). N’oubliez pas d’annuler les modifications qui ont cassé la fonction.

Nous pouvons également vérifier que notre fonction déclenche bien une erreur comme prévu, en utilisant une approche légèrement différente de la méthode assertTrue. Pour commencer, ajoutez la méthode de test suivante à la classe de test.

1@Test(expected = Error.class)
2public void shouldThrowErrorForSQLInjection()
3{
4    App.generateUpdateUserFirstNameStatement("John", "abcdef1234567; DROP TABLE user;");
5}

Ici, nous avons utilisé l’annotation @Test pour indiquer une valeur attendue. Nous nous attendons à ce que notre méthode déclenche une instance de la classe Error, car c’est ainsi que nous l’avons programmée pour gérer la réception d’une injection SQL dans l’un ou l’autre paramètre. Nous pouvons maintenant exécuter les tests et vérifier qu’ils réussissent.

Nous avons implémenté avec succès nos premiers tests unitaires Java avec JUnit. Ils nous permettent de vérifier que notre code fonctionne comme prévu et produit les résultats corrects. Dans le cas contraire, notre test échouera.

Il est essentiel de protéger nos applications contre les vulnérabilités, notamment celles qui nous exposent aux injections SQL malveillantes. Ajouter un test de ce type peut éviter qu’un développeur introduise cette vulnérabilité à l’avenir. Les tests renforcent la confiance dans notre code et offrent un filet de sécurité aux développeurs qui y travailleront par la suite. Découvrez ici d’autres bonnes pratiques de sécurité Java.

Snyk Code est un autre outil capable de détecter les mauvaises pratiques de sécurité dont les développeurs n’ont pas forcément conscience et pour lesquelles ils n’ont pas écrit de tests. Il peut notamment repérer le code vulnérable aux injections SQL, ainsi que les informations sensibles codées en dur, comme les secrets d’API et les informations permettant d’identifier une personne.

Le test définit un contrat qui décrit le comportement attendu de la méthode. Si un développeur souhaite mettre à jour la méthode generateUpdateUserFirstNameStatement et la casse involontairement — comme nous l’avons fait pour notre deuxième test —, le test unitaire échoue et fournit des informations sur le problème. Cette pratique ajoute une couche de protection contre la rupture des fonctionnalités essentielles et la mise en production de modifications instables ou dangereuses.

Conclusion

Comme nous l’avons vu dans ce tutoriel, écrire des tests unitaires est un moyen simple de vérifier que notre code se comportera comme prévu dans toutes sortes de situations. De plus, les tests unitaires offrent une protection contre les erreurs dans les projets collaboratifs : ils empêchent les autres développeurs de casser accidentellement notre code ou d’introduire des vulnérabilités. Bien qu’ils ne soient pas le seul moyen de tester une application, les tests unitaires devraient faire partie de la boîte à outils de tout développeur.

Consultez ces articles connexes pour approfondir vos connaissances techniques sur Java :

• Sérialisation et désérialisation en Java

• Aide-mémoire sur l’inférence de type local en Java

• Bonnes pratiques pour gérer les dépendances Java