key successful unit testing how developers test their own code
Testeurs Black Box ne vous souciez pas des tests unitaires. Leur objectif principal est de valider l'application par rapport aux exigences sans entrer dans les détails de mise en œuvre.
Mais par curiosité ou Pensée hors de la boîte , vous êtes-vous déjà demandé comment les développeurs testent leur code? Quelle méthode utilisent-ils pour tester avant de publier du code pour le test? En quoi les tests de développement sont-ils importants dans un processus agile? La réponse à tout cela est le test unitaire. Je souhaite vous informer de l'importance des tests unitaires afin que les équipes de développement et de test puissent travailler de manière plus collaborative pour concevoir, tester et publier une excellente application.
Qui sait à l'avenir, certains d'entre vous pourraient même passer aux tests en boîte blanche et utiliser ces techniques de validation et d'amélioration du code!
Ce que vous apprendrez:
Qu'est-ce que le test unitaire?
Les tests unitaires ne sont pas un nouveau concept. Il existe depuis les débuts de la programmation. Habituellement, les développeurs et parfois Testeurs de boîtes blanches écrire des tests unitaires pour améliorer la qualité du code en vérifiant chaque unité du code utilisée pour implémenter les exigences fonctionnelles (aka test conduit au développement TDD ou test-first development).
La plupart d'entre nous connaissent peut-être la définition classique -
«Le test unitaire est la méthode qui permet de vérifier le plus petit morceau de code testable par rapport à son objectif.» Si l'objectif ou l'exigence a échoué, le test unitaire a échoué.
En termes simples, cela signifie - écrire un morceau de code (test unitaire) pour vérifier le code (unité) écrit pour la mise en œuvre des exigences.
Test unitaire dans SDLC
Dans les tests unitaires, les développeurs utilisent des tests manuels ou automatisés pour s'assurer que chaque unité du logiciel répond aux exigences du client. Cette unité peut être une fonction, un objet, une méthode, une procédure ou un module individuel du logiciel testé.
L'écriture de tests unitaires pour tester les unités individuelles facilite l'écriture de tests complets car toutes les unités sont rassemblées. Pendant le développement du logiciel, il s'agit du premier niveau de test.
Importance de la rédaction de tests unitaires
Les tests unitaires sont utilisés pour concevoir des composants logiciels robustes qui aident à maintenir le code et à éliminer les problèmes dans les unités de code. Nous savons tous combien il est important de détecter et de corriger les défauts au tout début du cycle de développement logiciel. Ce test sert le même objectif.
Il fait partie intégrante du processus de développement logiciel agile. Lorsqu'une suite de tests unitaires de construction nocturne doit s'exécuter et qu'un rapport doit être généré. Si l'un des tests unitaires a échoué, l'équipe QA ne doit pas accepter cette version pour vérification.
Si nous définissons cela comme un processus standard, de nombreux défauts seraient détectés au début du cycle de développement, ce qui permettrait d'économiser beaucoup de temps de test.
Je sais que de nombreux développeurs détestent écrire des tests unitaires. Ils ignorent ou écrivent de mauvais cas de test unitaires en raison d'une planification serrée ou d'un manque de sérieux (oui, ils écrivent des tests unitaires vides, donc 100% d'entre eux réussissent ;-)). Il est important d’écrire de bons tests unitaires ou de ne pas les écrire du tout. Il est encore plus important de fournir assez de temps et un environnement favorable pour des avantages réels.
Méthodes de test unitaire
Elle peut être réalisée de 2 manières:
- Test manuel
- Test automatisé
Dans Test manuel , le testeur exécute manuellement les cas de test sans utiliser d'outil d'automatisation. Ici, chaque étape du test est exécutée manuellement. Les tests manuels sont fastidieux, en particulier pour les tests répétitifs et nécessitent plus d'efforts pour créer et exécuter des cas de test. Les tests manuels ne nécessitent la connaissance d'aucun outil de test.
C'est un fait que 100% de l'automatisation n'est pas possible et qu'il y aura donc toujours un certain niveau de test manuel effectué.
Dans Test automatisé, Les outils d'automatisation des tests logiciels sont utilisés pour automatiser les tests / cas de test. L'outil d'automatisation peut enregistrer et sauvegarder votre test et il peut être rejoué autant de fois que nécessaire sans aucune autre intervention humaine.
Ces outils peuvent même entrer des données de test dans le système testé et comparer les résultats attendus aux résultats réels et générer automatiquement les rapports. Cependant, le coût initial de la mise en place d'outils d'automatisation des tests est élevé.
Techniques dans les tests unitaires
# 1) Test de la boîte blanche:
entretien de analyste du support technique questions et réponses
Dans les tests en boîte blanche, le testeur connaît la structure interne du logiciel, y compris le code, et peut le tester par rapport à la conception et aux exigences. Par conséquent, le test de la boîte blanche est également connu sous le nom de test transparent .
# 2) Test de la boîte noire:
Dans les tests boîte noire, le testeur ne connaît ni les structures internes ni le code du logiciel.
# 3) Test de la boîte grise:
Ceci est également appelé test technique semi-transparent ce qui signifie, les testeurs ne sont que partiellement conscients de la structure interne, des fonctions et des conceptions ainsi que des exigences. Le débogage est effectué par une entrée réelle du front-end pour obtenir des données exactes dans le back-end. La boîte grise est donc considérée comme une combinaison de techniques de test boîte noire et boîte blanche.
Les tests en boîte grise couvrent les types de tests suivants:
- Test matriciel.
- Test de modèle.
- Test de modèle orthogonal.
- Les tests de régression.
Avantages des tests unitaires
- Le processus devient agile: Pour ajouter de nouvelles fonctions ou fonctionnalités au logiciel existant, nous devons apporter des modifications à l'ancien code. Mais changer les choses avec le code déjà testé peut être à la fois risqué et coûteux.
- La qualité du code s'améliore: La qualité du code est automatiquement améliorée lorsque les tests unitaires sont effectués. Les bogues identifiés lors de ce test sont corrigés avant qu'il ne soit envoyé pour la phase de test d'intégration. Il en résulte une conception et un développement robustes lorsque les développeurs écrivent des cas de test en comprenant d'abord les spécifications.
- Détecte les bogues tôt: Lorsque les développeurs exécutent des tests unitaires, ils détectent les bogues tôt dans le cycle de vie du développement logiciel et les résolvent. Cela inclut des failles ou des parties manquantes dans la spécification ainsi que des bogues dans l'implémentation du programmeur.
- Changements plus faciles et intégrations simplifiées: Les tests unitaires permettent au développeur de restructurer facilement le code, d'apporter des modifications et de maintenir le code. Cela facilite également le test du code après l'intégration. La résolution d'un problème dans les tests unitaires peut résoudre de nombreux autres problèmes survenant lors des étapes ultérieures de développement et de test
- Disponibilité de la documentation: Les développeurs qui examinent la fonctionnalité à un stade ultérieur peuvent se référer à la documentation des tests unitaires et peuvent facilement trouver l'interface de test unitaire et corriger ou travailler rapidement et facilement.
- Processus de débogage facile: Cela aide à simplifier le processus de débogage. Si le test échoue à un stade quelconque, le code doit être débogué ou bien le processus peut être poursuivi sans aucun obstacle.
- Moindre coût: Lorsque des bogues sont détectés et résolus pendant les tests unitaires, le coût et le temps de développement sont réduits. Sans ces tests, si les mêmes bogues sont détectés à un stade ultérieur après l'intégration du code, il devient plus difficile à tracer et à résoudre, ce qui le rend plus coûteux et augmente le temps de développement.
- L'exhaustivité du code peut être démontrée à l'aide de tests unitaires: Ceci est plus utile dans le processus agile. Les testeurs ne testent pas les versions fonctionnelles tant que l'intégration n'est pas terminée. La complétion du code ne peut pas être justifiée en montrant que vous avez écrit et vérifié le code. Mais l'exécution de tests unitaires peut démontrer l'exhaustivité du code.
- Gain de temps de développement: L'achèvement du code peut prendre plus de temps, mais en raison de moins de bogues dans les tests du système et d'acceptation, le temps de développement global peut être économisé.
- Couverture de code peut être mesuré
Cycle de test unitaire
[image la source ]
Qu'est-ce qui fait un bon test unitaire?
Eh bien, je ne suis pas la bonne personne pour dire ce qui fait un bon test unitaire, mais sur la base de mes observations sur divers projets, je peux dire les caractéristiques d’un bon test unitaire. Le mauvais test unitaire n'ajoute pas de valeur au projet. Au lieu de cela, le coût du projet augmente considérablement l'écriture et la gestion des mauvais tests unitaires.
Comment rédiger de bons tests unitaires?
- Un test unitaire doit être écrit pour vérifier une seule unité de code et non l'intégration.
- Des tests unitaires petits et isolés avec une dénomination claire le rendraient très facile à écrire et à maintenir.
- Changer une autre partie du logiciel ne devrait pas affecter le test unitaire si ceux-ci sont isolés et écrits pour une unité de code spécifique.
- Il devrait fonctionner rapidement
- Un test unitaire doit être réutilisable
Cadres de tests unitaires
Les frameworks de tests unitaires sont principalement utilisés pour aider à écrire des tests unitaires rapidement et facilement. La plupart des langages de programmation ne prennent pas en charge les tests unitaires avec le compilateur intégré. Des outils tiers open source et commerciaux peuvent être utilisés pour rendre les tests unitaires encore plus amusants.
Liste des populaires Outils de test unitaire pour différents langages de programmation:
- Framework Java - JUnit
- Framework PHP - PHPUnit
- Framework C ++ - UnitTest ++ et Google C ++
- Framework .NET - NUnit
- Framework Python - py.test
Idées fausses et vérités
- Il faut plus de temps pour écrire du code avec des cas de test unitaires, et nous n’avons pas le temps pour cela. En réalité, cela vous ferait gagner du temps de développement à long terme.
- Les tests unitaires trouveront tous les bogues - Ce ne sera pas le cas, car le but du test unitaire n'est pas de trouver des bogues mais de développer des composants logiciels robustes qui présenteront moins de défauts dans les étapes ultérieures du SDLC.
- Une couverture de code à 100% signifie une couverture de test à 100% - Cela ne garantit pas que le code est sans erreur.
Comment accepter les tests unitaires?
Un bon test unitaire peut être effectué en 3 parties de base.
- Ecrire le code de test unitaire
- Exécutez le code de test unitaire pour vérifier s'il répond à la configuration système requise
- Exécutez le code logiciel pour tester les défauts et si le code répond aux exigences du système.
Après avoir effectué les 3 étapes ci-dessus, si le code semble être correct, le test unitaire est dit avoir été réussi. Et s'il ne répond pas à la configuration système requise, le test échoue. Dans ce cas, le développeur doit revérifier et corriger le code.
Dans certains cas, il est nécessaire de séparer le code pour effectuer ces tests avec plus de précision.
Meilleur entrainement
Pour créer le meilleur code lors de ce test, tenez compte des points ci-dessous:
- Le code doit être fort: Il existe des cas où le test échoue ou, dans le pire des cas, ne s'exécute pas du tout si le code est cassé.
- Compréhensible et raisonnable: Le code doit être facile à comprendre. Cela permet au développeur d'écrire facilement le code et même les autres développeurs qui travailleront sur le code ultérieurement le trouveront facile à déboguer.
- Devrait être le cas unique: Les tests qui définissent plusieurs cas en un seul sont complexes à utiliser. Ainsi, l'écriture d'un code de cas unique est la meilleure pratique, ce qui facilite la compréhension et le débogage du code.
- Autoriser les tests automatisés: Les développeurs doivent s'assurer que le test s'exécute sous une forme automatisée. Il doit s'inscrire dans un processus de livraison ou d'intégration continue.
Les autres points à garder à l'esprit sont les suivants:
- Au lieu de créer des cas de test pour toutes les conditions, concentrez-vous sur le test qui affecte le comportement du système.
- Il y a des chances que le bogue se reproduise en raison du cache du navigateur.
- Les cas de test ne doivent pas être interdépendants.
- Faites également attention à l'état de la boucle.
- Planifiez les cas de test plus fréquemment.
Conclusion
Le test unitaire entre en scène lorsqu'il est nécessaire de tester chaque fonction séparément. Il est tout à fait raisonnable de détecter et de corriger les bogues pendant ces tests et d'économiser du temps et de l'argent, plutôt que de les trouver à un stade ultérieur du développement logiciel.
Bien qu'il offre de nombreux avantages, son utilisation présente également des limites. Une discipline et une cohérence rigoureuses sont requises tout au long du processus de développement logiciel pour surmonter les limites et obtenir les avantages escomptés.
Vos commentaires sont les bienvenus!
En tant que testeur boîte noire, quelles sont vos observations sur les tests unitaires dans votre équipe? Quelqu'un a-t-il une meilleure idée pour réussir les tests unitaires?
lecture recommandée
- Les différences entre les tests unitaires, les tests d'intégration et les tests fonctionnels
- 20 outils de test unitaire les plus populaires en 2021
- Ecrire des tests unitaires avec Spock Framework
- Meilleurs outils de test de logiciels 2021 [Outils d'automatisation des tests QA]
- Différences clés entre les tests de boîte noire et les tests de boîte blanche
- Test de charge avec les didacticiels HP LoadRunner
- Différence entre les tests de bureau, client-serveur et Web
- Qu'est-ce que le test gamma? La phase finale du test