Lorsque vous écrivez un logiciel, des erreurs sont inévitables dans votre code. Il peut s’agir d’erreurs de syntaxe, d’erreurs logiques, d’erreurs d’exécution, d’erreurs de performance, d’erreurs de données, ou pire encore.
La nature presque omniprésente des erreurs lors de l’écriture d’un logiciel fait des tests de logiciels une étape importante du développement de logiciels. Des tests appropriés et efficaces permettent non seulement d’obtenir des logiciels de haute qualité qui répondent aux besoins des utilisateurs, mais aussi des logiciels qui sont conformes aux réglementations et qui présentent peu ou pas de vulnérabilités susceptibles d’être exploitées par des attaquants.
Lestests de logiciels peuvent être effectués sous la forme de tests automatisés, de tests unitaires, de tests d’intégration ou de tests de l’ensemble du logiciel par le biais de tests de système.
Toutefois, une question importante qui se pose lors des tests de logiciels est de savoir comment déterminer si votre logiciel a été testé de manière exhaustive. Les tests que vous avez effectués sur le logiciel sont-ils suffisants ?
Avez-vous testé toutes les parties de votre logiciel ou y a-t-il des parties de code qui n’ont pas été testées du tout ?
De telles questions ne manqueront pas de se poser lors des tests de logiciels, d’où l’importance de la couverture de code.
La couverture decode est une mesure de test de logiciel qui vous indique la part de votre code qui a été exécutée et donc testée par les tests que vous avez exécutés sur le logiciel que vous testez. Les résultats de la couverture du code sont exprimés en pourcentage.
Ce pourcentage indique la part de votre code qui a été couverte par les tests que vous avez exécutés sur le code. Par exemple, si vous exécutez un test et obtenez une couverture de code de 60 %, cela signifie que 40 % de votre code n’a pas été couvert par les tests que vous avez écrits et qu’il peut donc y avoir des erreurs et des vulnérabilités dans le code non testé.
C’est pourquoi la couverture du code vous permet d’analyser l’efficacité et l’exhaustivité des tests que vous avez effectués sur votre logiciel. Cela présente l’avantage de garantir que le logiciel est correctement et complètement testé avant d’être publié. Cela permet de réduire les bogues dans les logiciels de production, qui pourraient affecter l’expérience des utilisateurs avec le logiciel.
Même si une couverture de code de 100 % ne signifie pas nécessairement que le logiciel que vous écrivez est totalement exempt d’erreurs, vous devez viser une couverture de code élevée pour garantir l’efficacité des tests de votre logiciel.
Dans les secteurs critiques tels que l’aérospatiale et la médecine, où les erreurs logicielles peuvent entraîner la mort, les réglementations exigent une couverture de code de 100 % pendant les tests.
Types de mesures de la couverture du code
Il existe plusieurs types de mesures de la couverture du code qui peuvent être mesurées lors du test d’un logiciel. Il s’agit notamment de
- Couverture des instructions – mesure le pourcentage d’instructions exécutables dans le code source qui ont été exécutées pendant les tests.
- Couverture desfonctions – mesure le pourcentage de fonctions définies qui ont été appelées pendant les tests.
- Couverturedes branches – mesure le pourcentage de branches ou de chemins possibles qui ont été exécutés à partir de tous les points de décision du code source. Elle est utilisée pour s’assurer que toutes les branches issues des structures de contrôle de décision telles que les instructions “if”, “switch” et “if else” ont été entièrement testées.
- Couverture des conditions – mesure le pourcentage d’expressions booléennes qui ont été testées à la fois pour des valeurs vraies et fausses.
- Couverture des boucles – mesure le pourcentage de boucles dans le code source qui ont été exécutées pendant les tests.
- Couverture des chemins – mesure le pourcentage de tous les chemins d’exécution possibles dans le code source qui ont été testés.
Les mesures ci-dessus sont généralement incluses dans un rapport sur la couverture du code.
Meilleures pratiques en matière de couverture du code
Certaines bonnes pratiques sont recommandées lors de la couverture du code pour garantir l’efficacité et la qualité de la couverture du code. Il s’agit notamment de
Avoir des objectifs de couverture clairs
Dans tout test de logiciel entrepris, fixez des pourcentages de couverture cibles pour chaque mesure de couverture de test appropriée. Cela présente l’avantage non seulement de fournir des objectifs de test clairs, mais aussi de contribuer à réduire les défauts dans les logiciels en orientant les efforts de l’équipe vers l’augmentation de la couverture du code. Cela permet également de s’assurer que les tests de logiciels reçoivent l’attention qu’ils méritent au cours du développement du logiciel.
L’accent mis sur la qualité des tests
Il est important de noter que la couverture du code indique simplement le pourcentage de code qui a été testé et ne montre pas s’il a été testé correctement ou si le logiciel est exempt de bogues. Par conséquent, plutôt que de se concentrer sur une couverture de code proche de 100 %, l’accent devrait être mis sur l’écriture de tests de qualité et efficaces qui testent correctement le logiciel et apportent une valeur ajoutée.
Augmenter la couverture du code dans un code qui change fréquemment
S’il peut être difficile d’obtenir une couverture de code élevée dans les grands projets, des efforts peuvent être déployés pour s’assurer que la couverture de code s’améliore au fil du temps.
Un bon moyen d’y parvenir est d’exiger une couverture de code élevée, supérieure à 90 %, pour chaque nouvelle modification apportée à la base de code du projet.
L’application d’une couverture de code au niveau de la validation est non seulement réaliste et faisable, mais elle garantit également que toute nouvelle modification apportée au logiciel bénéficie d’une excellente couverture de code.
Mesurer et analyser les données relatives à la couverture du code
Utilisez les résultats de la couverture du code pour identifier les domaines qui ont encore besoin d’être testés et pour guider les futurs efforts de test, en donnant la priorité aux domaines où la couverture du code est faible.
Analysez les données de couverture du code pour identifier les zones critiques d’une application qui n’ont pas encore été testées et orientez vos efforts pour tester entièrement les zones critiques non testées. L’utilisation des données de couverture du code pour améliorer et hiérarchiser les logiciels permet d’obtenir des logiciels mieux testés et moins défectueux.
Couverture du code et couverture des tests
Bien qu’elles soient toutes deux utilisées pour vérifier l’efficacité des tests, la couverture du code et la couverture des tests sont fondamentalement différentes dans leur utilisation et dans ce qu’elles mesurent.
La couverture des tests est une mesure utilisée pour déterminer dans quelle mesure les tests écrits couvrent les exigences du logiciel. Elle implique de tester chaque exigence du logiciel et permet de déterminer dans quelle mesure le logiciel a été testé en ce qui concerne le respect de ses exigences.
Les résultats de la couverture des tests indiquent le pourcentage des exigences logicielles qui ont été testées. La couverture des tests est généralement effectuée par des professionnels de l’assurance qualité.
La couverture du code, quant à elle, est une mesure de test de logiciel utilisée pour déterminer le pourcentage du code source qui a été exécuté par les tests écrits.
Les résultats d’une couverture de code montrent dans quelle mesure les déclarations, fonctions, chemins, boucles, branches et conditions du code source ont été exécutés par les tests unitaires écrits. La couverture du code est utilisée pour évaluer dans quelle mesure les tests écrits couvrent le code source et est généralement effectuée par les développeurs de logiciels.
La couverture du code est un indicateur important à mesurer lors des tests de logiciels. Voici quelques outils pour vous aider avec la couverture du code :
Clover
Clover est un outil de couverture de code open-source initialement développé par Atlassian, un éditeur de logiciels australien qui développe des produits pour les équipes de développement de logiciels. L’outil est écrit purement en Java et peut fonctionner sur n’importe quel système d’exploitation satisfaisant aux exigences de l’environnement d’exécution Java (Java Runtime Environment).
Clover peut être utilisé pour effectuer une couverture de code sur du code écrit dans les langages de programmation Java, Groovy ou AspectJ. Il prend en charge des cadres de test tels que JUnit, TestNG et Spock, et peut également être intégré à des IDE tels qu’IntelliJ IDEA et Eclipse.
Clover peut être utilisé pour mesurer les métriques de couverture de code telles que la couverture des méthodes, des instructions, des branches, globale et par test.
À partir d’un exercice de couverture de code, il peut générer des rapports HTML hautement configurables qui montrent les résultats de la couverture de code ainsi que les principaux domaines de risque dans le logiciel et qui peuvent être utilisés pour l’optimisation des tests.
Les rapports peuvent également être générés en PDF, XML, JSON ou en texte brut. Les principaux avantages de clover sont qu’il peut être intégré à de nombreux outils différents et qu’il est activement développé et amélioré.
JaCoCo
JaCoCo est une bibliothèque gratuite de couverture de code pour le langage de programmation Java développée par l’équipe d’EclEmma. La bibliothèque est implémentée dans EclEmma, un outil gratuit de couverture de code Java pour l’IDE Eclipse.
JaCoCo fournit une analyse de couverture riche dont les résultats sont immédiatement résumés et mis en évidence dans l’éditeur de code source Java et permet aux utilisateurs d’explorer les résultats de couverture jusqu’au niveau de la méthode.
Les résultats sont présentés à l’aide d’un code couleur personnalisable qui met en évidence les lignes de code qui ont été entièrement, partiellement ou pas encore couvertes par les tests exécutés sur le code source. Il permet de fusionner et de prendre en compte différents tests afin d’obtenir une couverture totale du code source.
JaCoCo est un outil léger qui ne nécessite pas de modifier vos projets ou d’effectuer d’autres configurations pour l’utiliser dans le cadre de l’analyse de la couverture du code.
Cobertura
Cobertura est un outil de couverture de code Java libre et gratuit qui est basé sur Jcoverage et peut être utilisé seul, par le biais d’un script Ant, ou par le biais du plugin Maven. L’utilisation du plugin Maven est la manière la plus courante d’utiliser Cobertura pour la couverture de code.
Cobertura mesure le pourcentage de lignes ou de branches qui ont été exécutées par les tests effectués sur un code source Java. Il fournit des mesures telles que la couverture des lignes, qui indique le pourcentage d’instructions exécutées pendant les tests, et la couverture des branches, qui indique le pourcentage de branches couvertes pendant les tests.
Il indique également un facteur de complexité qui augmente avec le nombre de branches dans votre code Java.
Les résultats de la couverture du code sont présentés en HTML ou en XML, indiquant les parties du code source qui n’ont pas été testées. Outre les résultats de la couverture des tests, Cobertura peut également être utilisé pour localiser le code non testé et les bogues, ainsi que pour identifier le code inaccessible.
Istanbul
Istanbul est un outil de couverture de code pour le code JavaScript avec le support de ES6. Cet outil peut être installé dans n’importe quel projet Javascript en tant que dépendance de développement à l’aide du gestionnaire de paquets node.
Istanbul fournit des mesures de couverture de code telles que la couverture des instructions, des branches, des fonctions et des lignes. Il montre également les lignes du code source qui n’ont pas été couvertes par les tests. Pour ce faire, il ajoute des compteurs de lignes à votre code JavaScript afin de pouvoir suivre la mesure dans laquelle vos tests unitaires exécutent votre code source.
Les résultats de la couverture du code par Istanbul peuvent être affichés dans le terminal ou sous forme de HTML. En outre, Istanbul offre un support pour les applications qui génèrent des sous-processus, la couverture de Babel et des projets TypeScript.
Pytest-cov
Pytest-cov est un plugin Python gratuit utilisé pour générer des rapports de couverture de code pour le code Python. Il est installé à l’aide de l’installateur de paquets Python Pip et est utilisé à partir de la ligne de commande.
Son rapport de couverture de code montre les instructions de votre projet Python, celles qui ne sont pas couvertes par des tests, et il fournit un pourcentage de couverture de test montrant le pourcentage de votre code Python couvert par des tests.
Pytest-cov offre le support des sous-processus, le support de xdist, et un comportement cohérent de pytest. Le comportement par défaut de Pytest-cov lors de l’exécution des tests est de supprimer les fichiers de données de couverture existants afin de garantir des données nouvelles et propres pour chaque nouvelle exécution de test. Cependant, il permet également aux utilisateurs de combiner les résultats des tests de couverture de code des exécutions de test précédentes.
Coverage.py
Coverage.py est un outil de couverture de code pour les programmes Python, et il est installé dans les projets à l’aide de pip.
Par défaut, il mesure la couverture des lignes ou des instructions et fournit des résultats indiquant le nombre d’instructions dans le programme, celles qui ont été manquées par les tests, ainsi que le pourcentage de couverture par rapport au test. Cependant, il peut toujours être configuré pour mesurer la couverture des branches dans les programmes Python.
Coverage.py peut également être utilisé pour indiquer quels tests ont exécuté quelles lignes du code source. Son rapport de couverture de code peut être présenté dans le terminal et également aux formats HTML, XML, JSON et LCOV.
SimpleCov
SimpleCov est un outil robuste de couverture de code pour le langage de programmation Ruby. Il utilise la bibliothèque de couverture intégrée à Ruby pour collecter des données pertinentes à utiliser pour déterminer la couverture du code après l’exécution des tests.
Le point fort de SimpleCov est sa présentation des résultats de la couverture du code. Il fusionne également les résultats des différents types de tests effectués de sorte que le rapport généré montre les résultats de tous les tests effectués, ce qui permet d’identifier facilement les parties non testées du code.
Il formate également le code source avec des codes de couleur qui peuvent être facilement utilisés pour identifier les parties testées et non testées du code. Par défaut, SimpleCov mesure et rapporte la couverture des lignes de tests. Cependant, il peut être configuré pour mesurer et rapporter la couverture des branches des tests effectués.
Deep Cover
Deep Cover est un outil de couverture de code précis pour le code Ruby. Il offre des rapports de couverture de ligne plus précis en s’assurant qu’une ligne n’est considérée comme couverte que lorsqu’elle est exécutée entièrement et non partiellement.
De plus, il offre un support pour la couverture des nœuds et des branches qui peut être utilisé optionnellement pour découvrir s’il y a des branches qui ne sont pas prises par les tests.
Deep Cover n’est pas seulement facile à utiliser sans configuration, mais il peut être intégré dans des projets utilisant d’autres outils de couverture de code tels que la bibliothèque de couverture de code intégrée à Ruby ou SimpleCov. Dans de tels cas, Deep Cover rend les outils plus stricts en ne marquant les lignes comme étant exécutées que si tout ce qui se trouve sur la ligne de code est entièrement exécuté.
Conclusion
Bien qu’une couverture de code élevée ne se traduise pas nécessairement par un logiciel exempt d’erreurs, il s’agit d’une mesure cruciale qui doit être prise en compte lors du test d’un logiciel. La couverture du code est importante pour évaluer dans quelle mesure les tests écrits testent réellement le code source d’un logiciel.
En outre, si l’on s’efforce d’améliorer la couverture du code pendant les tests, on obtient un logiciel mieux testé et moins sujet aux erreurs en production. Pour réaliser la couverture du code lors des tests de logiciels, envisagez d’utiliser les outils suggérés dans l’article.
Vous pouvez également explorer les outils de test de charge basés sur le cloud.