Lors de la conception d’un logiciel, des erreurs sont pratiquement inévitables. Ces imperfections peuvent se manifester sous diverses formes : erreurs de syntaxe, erreurs logiques, erreurs d’exécution, problèmes de performance, altération des données, ou même des failles de sécurité majeures.
L’omniprésence des erreurs dans le développement de logiciels fait des tests une étape essentielle. Des tests bien conçus et rigoureux permettent de garantir que les logiciels non seulement répondent aux exigences des utilisateurs, mais sont également conformes aux normes en vigueur et exempts de vulnérabilités exploitables.
Les tests logiciels peuvent être réalisés de différentes manières, allant des tests automatisés aux tests unitaires, en passant par les tests d’intégration et les tests de l’ensemble du système.
Toutefois, une question importante se pose : comment déterminer si les tests réalisés sont suffisamment exhaustifs ? Les tests effectués couvrent-ils toutes les parties du logiciel de manière adéquate ?
Est-ce que toutes les composantes du logiciel ont été rigoureusement testées, ou existe-t-il des portions de code qui ont été négligées ?
Ces interrogations sont inhérentes au processus de test, ce qui souligne l’importance de la couverture de code.
La couverture de code est une mesure qui indique la proportion du code qui a été exécutée et, par conséquent, testée par les tests réalisés. Les résultats sont généralement exprimés en pourcentage.
Ce pourcentage représente donc la part du code qui a été soumise à des tests. Par exemple, une couverture de 60% signifie que 40% du code n’a pas été testé, et que ces zones non couvertes peuvent potentiellement receler des erreurs ou des failles de sécurité.
La couverture de code permet ainsi d’évaluer l’efficacité et la complétude des tests. L’objectif principal est de s’assurer que le logiciel est minutieusement testé avant sa mise en production, ce qui réduit le risque de rencontrer des bugs susceptibles d’affecter l’expérience utilisateur.
Bien qu’une couverture de 100% ne garantisse pas l’absence totale d’erreurs, il est essentiel de viser une couverture élevée pour assurer l’efficacité du processus de test.
Dans des secteurs critiques comme l’aérospatiale ou la médecine, où les erreurs logicielles peuvent avoir des conséquences graves, des réglementations exigent parfois une couverture de code totale (100%) pendant les tests.
Types de mesures de couverture de code
Différents types de mesures de couverture de code peuvent être utilisés lors des tests logiciels. En voici quelques-uns :
- Couverture d’instructions : mesure le pourcentage d’instructions exécutables du code source qui ont été exécutées pendant les tests.
- Couverture de fonctions : mesure le pourcentage de fonctions définies qui ont été appelées pendant les tests.
- Couverture de branches : mesure le pourcentage de chemins possibles qui ont été empruntés lors de l’exécution, en particulier au niveau des points de décision du code source (instructions « if », « switch », etc.). Il s’assure que tous les cas possibles de ces structures de contrôle ont été testés.
- Couverture de conditions : mesure le pourcentage d’expressions booléennes qui ont été évaluées à la fois comme vraies et comme fausses.
- Couverture de boucles : mesure le pourcentage de boucles du code source qui ont été exécutées pendant les tests.
- Couverture de chemins : mesure le pourcentage de chemins d’exécution possibles qui ont été testés.
Ces indicateurs sont généralement inclus dans un rapport de couverture de code.
Meilleures pratiques en matière de couverture de code
Pour une couverture de code efficace et de haute qualité, certaines pratiques sont recommandées :
Définir des objectifs clairs
Pour tout test entrepris, il est essentiel de définir des objectifs de couverture précis pour chaque mesure pertinente. Ces objectifs permettent non seulement de structurer les tests, mais également de réduire le nombre de défauts dans le logiciel en encourageant l’équipe à améliorer la couverture du code. Cela permet également de s’assurer que les tests reçoivent l’attention nécessaire.
Privilégier la qualité des tests
Il est important de souligner que la couverture de code indique simplement le pourcentage de code qui a été exécuté, mais n’informe pas sur la qualité des tests ni sur l’absence de bugs. Par conséquent, au lieu de simplement viser une couverture maximale, l’accent doit être mis sur la qualité des tests, afin qu’ils soient pertinents et qu’ils apportent une valeur ajoutée au logiciel.
Améliorer la couverture du code pour les modifications fréquentes
Bien qu’il puisse être difficile d’obtenir une couverture élevée pour les grands projets, il est possible d’améliorer la couverture au fil du temps.
Une méthode efficace consiste à exiger une couverture de code élevée, supérieure à 90 %, pour toute nouvelle modification du code.
Cette approche au niveau des commits garantit que toute modification est accompagnée d’une couverture de code solide.
Mesurer et analyser les données de couverture de code
Exploitez les résultats de la couverture de code pour identifier les zones qui nécessitent davantage de tests et pour orienter les efforts de test futurs en priorisant les zones où la couverture est faible.
L’analyse de ces données permet de cibler les zones critiques du logiciel qui n’ont pas été testées, et donc d’optimiser les tests, ce qui aboutit à un logiciel de meilleure qualité, avec moins d’erreurs.
Couverture de code vs couverture des tests
Bien que les deux mesures permettent d’évaluer l’efficacité des tests, la couverture de code et la couverture des tests diffèrent fondamentalement dans leur objectif et dans ce qu’elles mesurent.
La couverture des tests mesure dans quelle mesure les tests effectués couvrent les exigences du logiciel. Cela implique de tester toutes les exigences du logiciel et aide à déterminer dans quelle mesure le logiciel a été testé par rapport à ces exigences.
Les résultats indiquent le pourcentage d’exigences qui ont été testées. La couverture des tests est généralement réalisée par des professionnels de l’assurance qualité.
La couverture de code, quant à elle, est une métrique utilisée pour déterminer le pourcentage du code source qui a été exécuté par les tests.
Les résultats montrent dans quelle mesure les instructions, fonctions, chemins, boucles, branches et conditions ont été exécutés par les tests unitaires. La couverture de code est utilisée pour évaluer dans quelle mesure les tests couvrent le code source et est généralement effectuée par les développeurs.
La couverture de code est un indicateur important à mesurer lors des tests logiciels. Voici quelques outils qui peuvent vous aider :
Clover
Clover est un outil open source de couverture de code, développé initialement par Atlassian. Il est écrit en Java et peut fonctionner sur tout système d’exploitation compatible avec l’environnement d’exécution Java.
Clover peut être utilisé pour effectuer une analyse de couverture sur du code écrit en Java, Groovy ou AspectJ. Il prend en charge les frameworks de test comme JUnit, TestNG et Spock, et peut être intégré à des IDE comme IntelliJ IDEA et Eclipse.
Clover peut être utilisé pour mesurer plusieurs indicateurs, tels que la couverture de méthode, d’instruction, de branche, globale et par test.
Il génère des rapports HTML configurables, qui présentent les résultats de couverture de code, mettent en évidence les zones à risque du logiciel et peuvent être utilisés pour optimiser les tests.
Les rapports peuvent également être générés aux formats PDF, XML, JSON ou texte brut. Les principaux avantages de Clover sont sa capacité à être intégré à de nombreux outils et son développement actif.
JaCoCo
JaCoCo est une bibliothèque gratuite de couverture de code pour Java, développée par l’équipe EclEmma. Elle est intégrée à EclEmma, un outil de couverture de code gratuit pour l’IDE Eclipse.
JaCoCo fournit une analyse de couverture détaillée, dont les résultats sont résumés et mis en évidence dans l’éditeur de code Java, permettant d’explorer les résultats de la 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 qui ont été totalement, partiellement ou pas du tout couvertes par les tests. Il permet la fusion et la prise en compte de différentes exécutions de test afin d’arriver à une couverture totale du code source.
JaCoCo est un outil léger et ne nécessite pas de modifications de configuration dans vos projets pour l’analyse de couverture.
Cobertura
Cobertura est un outil open source et gratuit de couverture de code Java, basé sur Jcoverage et qui peut être utilisé seul, via un script Ant ou via le plugin Maven. L’utilisation via un plugin Maven est la méthode la plus courante.
Cobertura mesure le pourcentage de lignes ou de branches qui ont été exécutées par les tests. Il fournit des mesures telles que la couverture de ligne, qui montre le pourcentage d’instructions exécutées pendant les tests, et la couverture de branche, qui montre le pourcentage de branches couvertes pendant les tests.
Il indique également un facteur de complexité, qui augmente avec le nombre de branches dans le code Java.
Les résultats sont présentés en HTML ou XML, indiquant les parties du code qui n’ont pas été testées. En plus d’afficher les résultats de la couverture de code, Cobertura peut être utilisé pour localiser le code non testé, les bugs et le code inaccessible.
Istanbul
Istanbul est un outil de couverture de code pour JavaScript, compatible ES6+. Il peut être installé dans n’importe quel projet JavaScript en tant que dépendance de développement à l’aide du gestionnaire de packages npm.
Istanbul fournit des mesures de couverture telles que la couverture des instructions, des branches, des fonctions et des lignes. Il met en évidence les lignes qui n’ont pas été couvertes par les tests, en ajoutant des compteurs de lignes au code JavaScript pour suivre l’exécution du code source par les tests unitaires.
Les résultats peuvent être affichés dans le terminal ou au format HTML. Istanbul prend également en charge les applications qui génèrent des sous-processus, ainsi que la couverture « source map » pour les projets Babel et TypeScript.
Pytest-cov
Pytest-cov est un plugin Python gratuit utilisé pour générer des rapports de couverture de code. Il s’installe via Pip et fonctionne en ligne de commande.
Il affiche les instructions du projet Python, celles qui ne sont pas couvertes par les tests, et fournit un pourcentage de couverture.
Pytest-cov offre la prise en charge des sous-processus, de xdist et un comportement pytest cohérent. Par défaut, il supprime les fichiers de données de couverture existants pour assurer des données propres à chaque exécution. Toutefois, il permet de combiner les résultats des tests précédents.
Coverage.py
Coverage.py est un outil de couverture de code pour Python, qui s’installe via pip.
Par défaut, il mesure la couverture des lignes et des instructions, fournit des résultats indiquant le nombre d’instructions, celles manquées par les tests et le pourcentage de couverture. Il indique également les lignes qui n’ont pas été testées. Il peut aussi être configuré pour mesurer la couverture des branches.
Coverage.py peut également être utilisé pour indiquer quels tests ont exécuté quelles lignes du code. Les rapports peuvent être présentés dans le terminal, ou aux formats HTML, XML, JSON et LCOV.
SimpleCov
SimpleCov est un outil de couverture de code pour le langage Ruby. Il utilise la bibliothèque de couverture intégrée de Ruby pour collecter les données pertinentes et déterminer la couverture de code après l’exécution des tests.
Son principal atout est la présentation des résultats. Il fusionne les résultats de différents types de tests afin d’identifier facilement les parties du code non testées.
Il utilise également un code couleur pour identifier facilement les parties testées et non testées du code. Par défaut, il mesure la couverture de ligne, mais il peut être configuré pour mesurer la couverture de branche.
Deep Cover
Deep Cover est un outil précis pour Ruby. Il offre des rapports de couverture de ligne plus précis, en garantissant qu’une ligne n’est considérée comme couverte que si 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.
Deep Cover est simple à utiliser et peut être intégré à d’autres outils tels que la bibliothèque de couverture intégrée de Ruby ou SimpleCov. Dans de tels cas, il rend les outils plus stricts en ne marquant les lignes comme 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 garantisse pas l’absence totale de bugs, il s’agit d’une mesure cruciale lors des tests logiciels. La couverture de code est importante pour évaluer l’efficacité des tests sur le code source d’un logiciel.
De plus, l’amélioration de la couverture du code pendant les tests contribue à un logiciel de meilleure qualité, moins sujet aux erreurs. Pour effectuer une couverture de code, pensez à utiliser les outils suggérés dans cet article.
Vous pouvez également explorer les outils de test de charge basés sur le cloud.