Tests unitaires avec JUnit et Mockito

Introduction aux tests unitaires

Qu’est-ce que les tests unitaires ?

Le test unitaire est un processus utilisé pour vérifier la fonctionnalité d’une unité ou d’une unité. Cette étape aide à l’estimation des codes par les autres membres de l’équipe et crée également un enregistrement de toutes les informations nécessaires, y compris les erreurs qui se produisent. Cela permet au développeur de corriger les erreurs avant que cela ne devienne un problème avec d’autres modules. Le code est exercé en faisant de petites modifications au lieu d’ajouter de nombreuses nouvelles lignes afin de couvrir tous les scénarios et de s’assurer qu’il n’y a pas de failles dans le programme.

Le test unitaire est le processus de test logiciel dans lequel un ensemble de composants de programme logiciel (méthodes) ou de modules sont testés individuellement. Cette technique vérifie efficacement l’implémentation de la fonctionnalité et l’exactitude d’une section de code en utilisant des stubs, des objets fictifs, des dépendances et des frameworks de tests unitaires.

Importance des tests unitaires

Pourquoi avons-nous besoin de tests unitaires ?

• Réduire les coûts de correction des bugs.
• Valider et corriger les bogues dans les premières étapes.
• Rend le processus de débogage simple et fluide.
• Refactoring de code sécurisé.
• Améliore la qualité du code.

Qualités des UTC et bonnes pratiques lors de la rédaction des UTC :

• Le code doit être fort et faiblement couplé.
• Les tests unitaires sont répétables et évolutifs.
• Ecrire des tests isolés.
• Les tests unitaires doivent être automatisés.
• Testez un scénario par test.
• Rédigez des tests lisibles et simples.
• « Testez-tout-ce-qui-peut-probablement-casser» stratégie de programmation.
• Devrait suivre AAA régner:
  • Organiser: Effectuez toutes les configurations (création d’objets fictifs, etc.) et les configurations pour tester la méthode/le système.
  • Loi: Exécutez l’action pour effectuer le test.
  • Affirmer – Vérifier la fonctionnalité de la méthode/du système.

Cadres de test unitaire

UnitTest Framework est une méthodologie de test par laquelle des unités individuelles de code source, telles que des classes, des méthodes et des fonctions, sont testées pour déterminer si elles exécutent correctement ou non leur fonctionnalité. Il comprend également la couverture et la qualité du code et les bonnes pratiques de codage.

Il existe plusieurs frameworks UnitTest disponibles selon les différents langages de programmation. Par exemple:

1. JUnit :

• • • Cadre de test unitaire open source pour JAVA
    • Prend en charge le concept de base de « d’abord tester puis coder”
    • Tests unitaires basés sur des annotations.Ex : @Test, @Before, @after etc..
    • Prend en charge divers outils de construction comme ANT, Maven, etc.

2. TestNG

• • cadre de test d’automatisation open source pour JAVA
  • conçu pour le langage de programmation Java
  • prend en charge les tests simultanés et offre une prise en charge des annotations

3. Embunit

• • un framework de test unitaire open source pour C/C++

4. Unité HTML

• • cadre de test unitaire open source pour HTML

JUnit

JUnit: Un cadre de test unitaire qui est largement utilisé pour tester le code écrit en JAVA. Il est utilisé pour vérifier la mise en œuvre de la fonctionnalité des modules et vérifier si les exigences ont été satisfaites ou non.

Quelques fonctionnalités saillantes de JUnit :

• Configuration du test et démontage: Configurer et démonter le contexte avant et après l’exécution du test respectivement.
• Affirme: Spécifiez la sortie attendue et comparez-la avec la sortie reçue.
• Test d’exception: teste et vérifie si une exception a été levée.
• Combinaisons d’essai: Les cas de test JUnit sont organisés en suites de tests pour une meilleure gestion.
• Intégration avec les systèmes de construction populaires: S’intègre aux systèmes de construction les plus populaires pour Java, y compris ANT et Maven.

Quelques annotations et déclarations Assert fréquemment utilisées dans JUnit :

• @Test: C’est la méthode de test à exécuter, Type de retour : vide public
• @Avant de: Exécuter avant @Test, Type de retour : vide public
• @Après: Exécuter après @Test, Type de retour : vide public
• @Avant les cours: Exécuté une fois avant l’une des méthodes de test de la classe, Type de retour : public vide statique
• @Après les cours: Exécuté une fois après que tous les tests de la classe ont été exécutés, Type de retour : vide statique public
• @Ignorer: Bloque l’exécution du scénario de test.

Exemple de classe de test :

Production :

La sortie du cas de test

Mockito

Qu’est-ce que Mockito ?

• Un cadre de simulation open source.
• Utilise une stratégie de test fictif, utilise des substituts d’objets pour valider le code.
• Langage de codage simple.

Qu’est-ce que la moquerie ?

• Basé sur le concept d’un objet factice (objet factice) qui remplace les objets réels.
• Teste les objets et les méthodes avec des dépendances.

Quelles sont les différentes phases du Mocking ?

• Stubbing : il spécifie comment l’objet se comportera lorsqu’il sera impliqué dans l’interaction.
• Expectation : définissez un objet tel qu’il indique les attentes lorsque le test est exécuté.
• Vérification : Confirme que les attentes ont été satisfaites.

Comment implémenter le Mockito dans JUnit ?

Il y a trois étapes pour implémenter le Mockito dans JUnit et ces étapes sont les suivantes :

• Création d’un objet factice
• Utiliser des stubs pour définir les attentes.
• Vérification à l’aide de mockito.

1. Création d’objet mock :

• Créez des objets fictifs dans JUnit en utilisant :
  • Statique faux() appel de méthode
  • @Faux annotation
• Un objet fictif est créé et utilisé pour tester le service

2. Utiliser des talons pour définir les attentes.

• Créez un stub et transmettez un argument à la méthode comme une simulation.
• Utilisez respectivement anyInt(), any(), anyString() selon l’argument nécessaire.
• Pour remplacer les appels de méthode Void :
  • Lorsque() méthode ne peut pas être utilisée.
  • Utilisation doReturn(result).when(mock_Object).void_method_Call()
  • Exceptions utilisant thenThrow() ou doThrow()

3. Vérification à l’aide de mockito.

• Utilisation Vérifier() méthode pour vérifier si les attentes fixées sont satisfaites.
• Vérifier peut vérifier le comportement de la méthode comme les invocations de méthode se sont produites deux fois/une fois, plusieurs fois ou jamais.

Exemple de cas de test implémentant Mockito dans JUnit :

Implémentation de Mockito dans JUnit

Quelques annotations importantes de Mockito :

• @espionner: Partial mock, qui suivra les interactions avec l’objet comme un mock.
• @Faux: créer un objet fictif d’une classe ou d’une interface.
• @InjectMock : injecter des dépendances simulées dans l’objet simulé de la classe annotée.

Assertion de classe :
Il s’agit d’une classe JUnit composée d’un ensemble de méthodes d’assertion utiles pour l’écriture de tests. Seules les assertions ayant échoué sont enregistrées. Ces méthodes peuvent être utilisées directement.
Exemple :

assertArrayEquals(booléen[] attendu, booléen[] actuels) : Affirme que deux tableaux booléens sont égaux.

assertArrayEquals(octet[] attendu, octet[] actuels) : Affirme que deux tableaux d’octets sont égaux.

assertArrayEquals(char[] attendu, char[] actuels) : Affirme que deux tableaux de caractères sont égaux.

assertNotNull(Object object) : Affirme qu’un objet n’est pas nul.

Pour plus de méthodes d’assertion de ce type : https://junit.org/junit4/javadoc/4.13/org/junit/Assert.html

Références

Wikipédia, tutorielspoint, javatpoint, junit.org

TROUVÉ CELA UTILE ? PARTAGEZ-LE