Qu'est-ce que le test unitaire?
UNIT TESTING est un type de test logiciel dans lequel des unités individuelles ou des composants d'un logiciel sont testés. Le but est de valider que chaque unité du code logiciel fonctionne comme prévu. Les tests unitaires sont effectués lors du développement (phase de codage) d'une application par les développeurs. Les tests unitaires isolent une section de code et vérifient son exactitude. Une unité peut être une fonction, une méthode, une procédure, un module ou un objet individuel.
Dans SDLC, STLC, modèle V, les tests unitaires sont le premier niveau de test effectué avant les tests d'intégration. Le test unitaire est une technique de test WhiteBox qui est généralement effectuée par le développeur. Cependant, dans un monde pratique en raison du manque de temps ou de la réticence des développeurs aux tests, les ingénieurs QA effectuent également des tests unitaires.
Dans ce didacticiel, vous apprendrez-
- Pourquoi les tests unitaires?
- Comment faire des tests unitaires
- Techniques de test unitaire
- Outils de test unitaire
- Développement piloté par les tests (TDD) et tests unitaires
- Mythe des tests unitaires
- Avantage des tests unitaires
- Inconvénients des tests unitaires
- Bonnes pratiques de test unitaire
Pourquoi les tests unitaires?
Les tests unitaires sont importants car les développeurs de logiciels essaient parfois de gagner du temps en effectuant des tests unitaires minimaux et c'est un mythe car les tests unitaires inappropriés entraînent des coûts élevés de correction des défauts pendant les tests système, les tests d'intégration et même les tests bêta après la création de l'application. Si des tests unitaires appropriés sont effectués au début du développement, cela économise du temps et de l'argent à la fin.
Voici les principales raisons d'effectuer des tests unitaires en génie logiciel:
- Les tests unitaires aident à corriger les bogues au début du cycle de développement et à réduire les coûts.
- Il aide les développeurs à comprendre la base de code de test et leur permet d'apporter des modifications rapidement
- Les bons tests unitaires servent de documentation de projet
- Les tests unitaires aident à la réutilisation du code. Migrez à la fois votre code et vos tests vers votre nouveau projet. Ajustez le code jusqu'à ce que les tests soient à nouveau exécutés.
Comment faire des tests unitaires
Afin de faire des tests unitaires , les développeurs écrivent une section de code pour tester une fonction spécifique dans l'application logicielle. Les développeurs peuvent également isoler cette fonction pour tester plus rigoureusement, ce qui révèle des dépendances inutiles entre la fonction testée et d'autres unités afin que les dépendances puissent être éliminées. Les développeurs utilisent généralement le cadre UnitTest pour développer des cas de test automatisés pour les tests unitaires.
Les tests unitaires sont de deux types
- Manuel
- automatique
Les tests unitaires sont généralement automatisés mais peuvent toujours être effectués manuellement. Le génie logiciel ne favorise pas l'un par rapport à l'autre, mais l'automatisation est préférée. Une approche manuelle des tests unitaires peut utiliser un document d'instructions étape par étape.
Dans le cadre de l'approche automatisée
- Un développeur écrit une section de code dans l'application juste pour tester la fonction. Ils commenteraient plus tard et supprimeraient finalement le code de test lorsque l'application est déployée.
- Un développeur pourrait également isoler la fonction pour la tester plus rigoureusement. Il s'agit d'une pratique de test unitaire plus approfondie qui implique le copier-coller de code dans son propre environnement de test que son environnement naturel. L'isolement du code permet de révéler les dépendances inutiles entre le code testé et d'autres unités ou espaces de données dans le produit. Ces dépendances peuvent alors être éliminées.
- Un codeur utilise généralement un Framework UnitTest pour développer des cas de test automatisés. À l'aide d'un cadre d'automatisation, le développeur code des critères dans le test pour vérifier l'exactitude du code. Pendant l'exécution des cas de test, le framework enregistre les cas de test en échec. De nombreux frameworks vont également automatiquement signaler et signaler, en résumé, ces cas de test ayant échoué. En fonction de la gravité d'un échec, le framework peut interrompre les tests ultérieurs.
- Le flux de travail des tests unitaires est 1) Créer des cas de test 2) Réviser / retravailler 3) Baseline 4) Exécuter des cas de test.
Techniques de test unitaire
Les techniques de test unitaire sont principalement classées en trois parties: le test de la boîte noire qui implique le test de l'interface utilisateur avec l'entrée et la sortie, le test de la boîte blanche qui implique de tester le comportement fonctionnel de l'application logicielle et le test de la boîte grise qui est utilisé pour exécuter le test. suites, méthodes de test, cas de test et analyse des risques.
Les techniques de couverture de code utilisées dans les tests unitaires sont répertoriées ci-dessous:
- Couverture de l'état
- Couverture décisionnelle
- Couverture de la succursale
- Couverture de l'état
- Couverture de la machine à états finis
Pour plus d'informations, reportez-vous à https://www.guru99.com/code-coverage.html
Exemple de test unitaire: objets simulés
Les tests unitaires reposent sur la création d'objets fictifs pour tester des sections de code qui ne font pas encore partie d'une application complète. Les objets factices remplissent les parties manquantes du programme.
Par exemple, vous pouvez avoir une fonction qui a besoin de variables ou d'objets qui ne sont pas encore créés. Dans les tests unitaires, ceux-ci seront pris en compte sous la forme d'objets fictifs créés uniquement aux fins des tests unitaires effectués sur cette section de code.
Outils de test unitaire
Il existe plusieurs logiciels de test unitaires automatisés disponibles pour aider aux tests unitaires. Nous vous donnerons quelques exemples ci-dessous:
- Junit: Junit est un outil de test gratuit utilisé pour le langage de programmation Java. Il fournit des affirmations pour identifier la méthode de test. Cet outil teste d'abord les données, puis inséré dans le morceau de code.
- NUnit: NUnit est un framework de test unitaire largement utilisé pour tous les langages .net. C'est un outil open source qui permet d'écrire des scripts manuellement. Il prend en charge les tests basés sur les données qui peuvent s'exécuter en parallèle.
- JMockit: JMockit est un outil de test unitaire open source. C'est un outil de couverture de code avec des métriques de ligne et de chemin. Il permet de se moquer de l'API avec une syntaxe d'enregistrement et de vérification. Cet outil offre une couverture de ligne, une couverture de chemin et une couverture de données.
- EMMA: EMMA est une boîte à outils open-source pour analyser et rapporter du code écrit en langage Java. Emma prend en charge les types de couverture comme la méthode, la ligne, le bloc de base. Il est basé sur Java, il est donc sans dépendances de bibliothèque externes et peut accéder au code source.
- PHPUnit: PHPUnit est un outil de test unitaire pour les programmeurs PHP. Il faut de petites portions de code appelées unités et tester chacune d'elles séparément. L'outil permet également aux développeurs d'utiliser des méthodes d'assertion prédéfinies pour affirmer qu'un système se comporte d'une certaine manière.
Ce ne sont là que quelques-uns des outils de test unitaire disponibles. Il y en a beaucoup plus, en particulier pour les langages C et Java, mais vous êtes sûr de trouver un outil de test unitaire pour vos besoins de programmation quel que soit le langage que vous utilisez.
Développement piloté par les tests (TDD) et tests unitaires
Les tests unitaires dans TDD impliquent une utilisation intensive des cadres de test. Un framework de test unitaire est utilisé afin de créer des tests unitaires automatisés. Les cadres de tests unitaires ne sont pas propres au TDD, mais ils y sont essentiels. Ci-dessous, nous examinons ce que TDD apporte au monde des tests unitaires:
- Les tests sont écrits avant le code
- Fiez-vous fortement aux frameworks de test
- Toutes les classes des applications sont testées
- Une intégration rapide et facile est rendue possible
Mythe des tests unitaires
Mythe: cela prend du temps et je suis toujours dépassé. Mon code est solide comme le roc! Je n'ai pas besoin de tests unitaires.
Les mythes, de par leur nature même, sont de fausses hypothèses. Ces hypothèses conduisent à un cercle vicieux comme suit -
La vérité est que les tests unitaires augmentent la vitesse de développement.
Les programmeurs pensent que le test d'intégration détecte toutes les erreurs et n'exécute pas le test unitaire. Une fois les unités intégrées, des erreurs très simples qui auraient pu très facilement être trouvées et corrigées dans l'unité testée prennent beaucoup de temps à être tracées et corrigées.
Avantage des tests unitaires
- Les développeurs qui cherchent à savoir quelles fonctionnalités sont fournies par une unité et comment l'utiliser peuvent consulter les tests unitaires pour acquérir une compréhension de base de l'API de l'unité.
- Les tests unitaires permettent au programmeur de refactoriser le code à une date ultérieure et de s'assurer que le module fonctionne toujours correctement (c'est-à-dire les tests de régression). La procédure consiste à écrire des cas de test pour toutes les fonctions et méthodes afin que chaque fois qu'un changement provoque un défaut, il puisse être rapidement identifié et corrigé.
- En raison de la nature modulaire des tests unitaires, nous pouvons tester des parties du projet sans attendre que d'autres soient terminées.
Inconvénients des tests unitaires
- On ne peut pas s'attendre à ce que les tests unitaires détectent toutes les erreurs d'un programme. Il n'est pas possible d'évaluer tous les chemins d'exécution même dans les programmes les plus triviaux
- Le test unitaire, de par sa nature même, se concentre sur une unité de code. Par conséquent, il ne peut pas détecter les erreurs d'intégration ou les erreurs générales au niveau du système.
Il est recommandé d'utiliser les tests unitaires en conjonction avec d'autres activités de test.
Bonnes pratiques de test unitaire
- Les cas de test unitaires doivent être indépendants. En cas d'améliorations ou de modifications des exigences, les cas de test unitaires ne devraient pas être affectés.
- Testez un seul code à la fois.
- Suivez des conventions de dénomination claires et cohérentes pour vos tests unitaires
- En cas de changement de code dans un module, assurez-vous qu'il existe un cas de test unitaire correspondant pour le module et que le module réussit les tests avant de modifier l'implémentation
- Les bogues identifiés lors des tests unitaires doivent être corrigés avant de passer à la phase suivante du SDLC
- Adoptez une approche "test comme votre code". Plus vous écrivez de code sans tester, plus vous avez de chemins pour rechercher des erreurs.
Résumé
- TEST D'UNITÉ est défini comme un type de test de logiciel où des unités ou composants individuels d'un logiciel sont testés.
- Comme vous pouvez le voir, les tests unitaires peuvent être très importants. Cela peut être complexe ou plutôt simple en fonction de l'application testée et des stratégies de test, des outils et des philosophies utilisés. Les tests unitaires sont toujours nécessaires à un certain niveau. C'est une certitude.