Passer en revue et configurer les résultats de couverture du code dans Azure Pipelines

Azure DevOps Services | Azure DevOps Server | Azure DevOps Server 2022

La couverture du code vous aide à déterminer la proportion du code de votre projet en cours de test, par exemple par les tests unitaires. Pour renforcer votre confiance en ce qui concerne les modifications du code et protéger efficacement contre les bogues, vos tests doivent exercer ou couvrir une grande proportion de votre code.

Lorsque vous passez en revue les résultats de la couverture du code, vous pouvez identifier les chemins de code que les tests ne couvrent pas. Ces informations vous aident à améliorer la couverture des tests au fil du temps en réduisant la dette de test.

Cet article explique comment afficher, configurer et dépanner la couverture du code dans Azure Pipelines. Vous apprenez comment configurer la couverture des modifications pour les pull requests, configurer les stratégies de couverture et résoudre les problèmes courants.

Formats, tâches et artefacts pris en charge

Formats pris en charge

Azure Pipelines peut publier des résultats de couverture via la tâche Publier les résultats de couverture du code v2. La tâche peut afficher les résultats dans 2 vues différentes :

• Pour cobertura, jacoco, clover, gcov, pcov et d'autres formats xml, une vue HTML est générée, contenant plus de détails sur le rapport de couverture du code et est préférée par la plupart des clients.
• Pour .coverage/.cjson/.covx : une vue tabulaire génère, contenant moins de détails que la vue HTML.

Artefacts et résultats

Vous pouvez afficher les artefacts de couverture du code publiés pendant la phase de construction sous l’onglet Résumé du récapitulatif de l'exécution du pipeline.

En outre, vous pouvez consulter les résultats du rapport de couverture du code sous l’onglet Couverture du code :

• Si vous publiez la couverture de code en utilisant les formats de couverture Cobertura ou JaCoCo, l'artifact de couverture de code contient un .html fichier que vous pouvez afficher hors connexion pour une analyse plus approfondie.
• Pour .NET et .NET Core, vous pouvez accéder au lien pour télécharger l’artefact en choisissant le jalon de couverture du code dans le résumé de la build.
• Visual Studio Test peut collecter une couverture pour les applications .NET et .NET Core. Il produit des .coverage fichiers que vous pouvez télécharger et utiliser pour une analyse plus approfondie dans Visual Studio.

Tasks

Publier les résultats de la couverture du code publie les résultats de couverture du code dans Azure Pipelines, qui ont été produits par une compilation au format Cobertura ou JaCoCo.

Les tâches intégrées telles que Visual Studio Test, .NET Core, Ant, Maven, Gulp, Grunt et Gradle offrent la possibilité de publier des données de couverture de code dans le pipeline.

Considérations relatives à Docker

Pour les applications qui utilisent Docker, vous pouvez exécuter des builds et des tests à l’intérieur du conteneur et générer des résultats de couverture du code dans le conteneur. Pour publier les résultats vers le pipeline, mettez à disposition les artefacts résultants pour la tâche Publier les résultats de la couverture du code. À titre de référence, consultez un exemple similaire pour publier des résultats de test dans la section Construire, tester et publier les résultats avec un fichier Docker.

Considérations importantes

• Dans un pipeline YAML multistage, les résultats de la couverture du code ne sont disponibles qu’une fois l’ensemble du pipeline terminé. Vous devrez peut-être séparer la phase de build dans son propre pipeline si vous souhaitez passer en revue les résultats de couverture du code avant le déploiement en production.
• La fusion des résultats de couverture du code à partir de plusieurs exécutions de test fonctionne actuellement uniquement pour .NET et .NET Core. Il n’existe aucun plan de prise en charge d’autres formats.

Couverture complète par rapport à la couverture différentielle

Couverture complète mesure la couverture de l'ensemble de la base de code d’un projet. Dans le contexte des demandes de tirage, les développeurs se concentrent sur les modifications qu’ils apportent et veulent savoir si les lignes de code spécifiques qu’ils ont ajoutées ou modifiées sont couvertes. Ce type de couverture est appelé couverture différentielle.

Les paramètres de couverture YAML diffèrent d’un pipeline YAML, car les paramètres de couverture s’appliquent à votre référentiel et sont utilisés quel que soit le pipeline qui génère votre code. Cette séparation signifie également que si vous utilisez des pipelines de build basés sur le concepteur classique, vous obtenez le contrôle de la couverture de code pour les pull requests.

Les indicateurs de couverture apparaissent dans la vue des fichiers modifiés, que les détails des commentaires des pull requests soient activés ou non.

Configurer la couverture des différences

Pour modifier les paramètres par défaut pour l'expérience de couverture de code des pull requests, incluez un fichier YAML de configuration nommé azurepipelines-coverage.yml à la racine de votre référentiel. Définissez les valeurs souhaitées dans ce fichier et Azure DevOps les utilise automatiquement la prochaine fois que le pipeline s’exécute.

Vous pouvez modifier les paramètres suivants :

Exemple de configuration

coverage:  
  status:                    # Code coverage status will be posted to pull requests based on targets defined below. 
    comments: on             # Off by default. When on, details about coverage for each file changed will be posted as a pull request comment.  
    diff:                    # Diff coverage is code coverage only for the lines changed in a pull request. 
      target: 60%            # Set this to a desired percentage. Default is 70 percent 

Vous trouverez plus d’exemples avec des détails dans le référentiel d’exemples YAML de couverture du code.

État de la couverture, détails et indicateurs

Lorsque vous configurez un pipeline pour collecter et publier les données de couverture de code, il publie un état de couverture de code lorsque vous créez une requête de tirage. Par défaut, le serveur vérifie que les tests couvrent au moins 70% de lignes modifiées. Vous pouvez modifier la cible de seuil de couverture de différences en une valeur que vous choisissez en modifiant le paramètre cible mentionné précédemment.

Le contrôle d'état calcule la couverture des modifications pour tous les fichiers de la pull request. Pour afficher le pourcentage de chaque fichier, activez Les détails comme décrit dans la section précédente. Lorsque cette option est activée, le système publie les détails sous la forme d’un commentaire sur le pull request.

Dans la vue des fichiers modifiés d’un pull request, les lignes de code modifiées sont également annotées avec des indicateurs de couverture pour indiquer si ces lignes sont couvertes.

Appliquer la protection de la branche avec une politique de couverture de code

Par défaut, la vérification de la couverture du code sur les requêtes de tirage est à titre indicatif - elle ne bloque pas les fusions avec une faible couverture. Pour garantir que les modifications répondent à un seuil de couverture minimal avant la fusion, configurez une stratégie de branche qui utilise la vérification de l’état de couverture.

L’état de la couverture du code publié à partir d’un pipeline suit la convention de nommage {name-of-your-pipeline/codecoverage}.

Guide de résolution des problèmes

Pourquoi est-ce que je vois des DLL en double dans la vue de la couverture de l’onglet Couverture du code ?

Vous pouvez voir des DLL en double lorsque .NET Core et .NET Framework sont utilisés dans le pipeline. Attendez-vous aux DLL dupliquées lorsque les deux sont utilisées, ce qui est par conception, car le même module provient de chemins différents.

Pourquoi n’y a-t-il pas de données de couverture sous l’onglet Couverture du code ?

Plusieurs raisons peuvent entraîner ce problème :

• Aucun test ou DLL n’est présent : si les fichiers ne contiennent pas de tests ou de DLL, la valeur de couverture est 0. Azure DevOps n’affiche pas les données de couverture du code dans l’onglet lorsque la valeur de couverture est 0. Au lieu de cela, il affiche un message sous l’onglet Couverture du code expliquant pourquoi il n’y a pas de données de couverture.

• XML de couverture vide : lorsque vous utilisez des tâches de couverture de code de publication, si la couverture .xml fournie en tant qu’entrée ne contient aucune information ni aucune ligne n’est couverte, aucune donnée de couverture n’apparaît sous l’onglet. Vérifiez pourquoi le fichier de couverture .xml (fichier d’entrée) est vide ou ne contient pas d’informations.

• Échecs de build : si la build échoue, l’onglet couverture du code s’affiche avec un message approprié.

• Configuration de la tâche VSTest : lorsque vous utilisez la tâche VSTest, si vous n’activez pas la vérification de la couverture du code ou si vous mentionnez des DLL incorrectes ou des chemins d’accès incorrects pour tester les fichiers dans le champ filtre de test, les données de couverture ne s’affichent pas.

• Problèmes de configuration de build : Il arrive que plusieurs valeurs de configuration de build existent et que vous ne définissez pas toutes les valeurs telles que BuildFlavor ou BuildPlatform. L’interface utilisateur affiche uniquement les valeurs des configurations de build particulières, c’est pourquoi d’autres modules sont manquants.

• Fichiers HTML volumineux : si le .html fichier est supérieur à 7 Mo, le rapport n’est pas disponible sous l’onglet Couverture du code. Pour contourner ce problème, téléchargez l’artefact « Couverture du code Report_* » à partir des artefacts publiés dans le résumé.

• Messages d’échec : si l’onglet Couverture du code contient un message d’échec lié à une erreur spécifique à l’utilisateur, examinez ce qui a déclenché ce message d’erreur.

Que dois-je faire si la vérification de l’état de couverture du code ne se termine jamais ou échoue ?

Pour activer la vérification de l’état de couverture du code, essayez d’ajouter le azurepipelines-coverage.yml fichier à la racine du référentiel. Vérifiez que le nom de fichier reste exactement le même. Voici un exemple :

coverage: 
  status: 
    comments: on 
    diff: 
      target: 50% 

Si la vérification de l’état de couverture échoue :

1. Vérifiez le pourcentage de couverture de différences. S’il est plus petit que la cible, essayez d’augmenter le pourcentage de couverture de différences.
2. Si la build a échoué pour une raison quelconque, cette défaillance peut également entraîner l’échec de la vérification de l’état de couverture du code.
3. Identifiez quelle tâche génère le fichier de couverture ou le rapport dans le pipeline. Vérifiez si la tâche charge correctement le rapport de couverture ou le fichier.
4. Les cas où les commentaires de couverture des différences indiquent « Aucune modification exécutable » ou « Aucune donnée de couverture de code trouvée » peuvent se produire en raison de lignes supprimées, d’introductions d’espaces blancs ou d’ajouts de commentaires. Ces cas sont des modifications non exécutables et ne sont pas significatives, de sorte que la couverture du code ne les signale pas.

Comment puis-je exclure certaines DLL de la couverture du code ?

Pour exclure les fichiers de la couverture du code, utilisez la classe ExcludeFromCodeCoverageAttribute.

Comment publier le résumé de couverture du code avec des détails appropriés en fusionnant plusieurs fichiers récapitulatives ?

La tâche Publier la couverture du code V1 ne prend pas en charge plusieurs fichiers récapitulatifs en tant qu’entrée. Utilisez plutôt la tâche Publish Code Coverage V2, qui prend en charge plusieurs formats de fichiers.

Vous pouvez également utiliser la tâche Générateur de Rapports pour fusionner tous les .xml fichiers, puis passer le chemin XML généré comme entrée à la tâche Publier le Code de Couverture.

Comment déclencher la vérification de la couverture du code ?

Pour les fichiers .html, les vérifications d’état de couverture ne sont pas prises en charge. Utilisez la tâche Build Quality Checks pour vérifier les résultats de la couverture du code.

Le rapport de l’onglet Couverture du code contient des nombres incorrects

Les données affichées sous l’onglet proviennent du fichier de couverture. Si vous utilisez des tâches personnalisées pour générer le fichier de couverture du code, vérifiez si le fichier ne contient pas de DLL ou de fichiers.

La stratégie de couverture du code est bloquée; quelle en est la cause ?

Plusieurs facteurs peuvent entraîner ce problème :

• Format de nom de politique de branche incorrect : vérifiez que le nom du pipeline correspond au nom de la politique de branche et n’a pas de caractères supplémentaires.

  

• Utilisation de PublishCodeCoverage V1 : la stratégie de couverture du code est bloquée et les commentaires ne sont pas générés. Utilisez plutôt la tâche PublishCodeCoverage V2.

• Trop de fichiers dans le PR : si le PR contient plus de 100 fichiers, la stratégie de couverture reste bloquée.

• Stratégies de couverture multiples : si vous configurez plusieurs stratégies de couverture, l’une d’elles est bloquée. Configurez une seule stratégie et supprimez l’autre stratégie bloquée.

J’ai vu 0 % de couverture des différences pour mes demandes de fusion même après avoir ajouté des tests.

Si vous ajoutez des tests pour couvrir les lignes de code modifiées ou nouvelles dans une pull request, mais vous voyez toujours 0 % de couverture de différences :

1. Vérifiez que les tests nouvellement ajoutés s’exécutent dans le cadre de la build.
2. Si les tests ne s’exécutent pas, vérifiez et mettez à jour la configuration pour les inclure dans la build, car la couverture ne peut pas être calculée si les tests ne s’exécutent pas.

Je ne vois pas le commentaire de couverture des différences sur la demande de tirage, même si je vois le rapport de couverture publié

Plusieurs facteurs peuvent entraîner ce problème :

• Version de la tâche : les commentaires de couverture des différences sont pris en charge uniquement avec la fonctionnalité Publier la Couverture de Code V2.
• Aucun changement exécutable : les commentaires sur la couverture des différences sont générés pour les fichiers contenant des modifications de code exécutable. Si le pull request comporte uniquement des mises à jour de configuration, Azure DevOps peut afficher la couverture de code en fonction de tous les tests exécutés pendant la build, mais il se peut qu'il n'y ait pas de couverture différentielle à calculer.
• Format de couverture : s’il existe des modifications de code fonctionnel et que le commentaire ne génère pas, vérifiez que le pipeline génère un rapport de couverture dans l’un des formats pris en charge mentionnés au début de cet article.

Dans l’onglet Couverture du code, je ne vois pas le rapport HTML approprié

En cas de problèmes lors de la génération du .html rapport, le système revient à une vue simplifiée.

Quels outils de couverture et formats de résultats peuvent être utilisés pour valider la couverture du code dans les demandes de tirage (pull request) ?

Actuellement, vous pouvez uniquement utiliser des formats de couverture Visual Studio Code (.coverage) pour valider la couverture du code pour les pull requests. Utilisez ce format si vous publiez la couverture du code à l’aide de la tâche de test Visual Studio, du verbe de test de la tâche .NET Core et de l’option TRX de la tâche Publier les résultats des tests.

Si plusieurs pipelines sont déclenchés lorsqu'une requête pull est soulevée, la couverture sera-t-elle fusionnée à travers les pipelines?

Si plusieurs pipelines sont déclenchés lorsqu'une pull request est élevée, la couverture du code ne s'agrège pas. Cette fonctionnalité est actuellement conçue pour un seul pipeline destiné à collecter et publier la couverture du code pour les pull requests. Si vous avez besoin de fusionner des données de couverture dans des pipelines, soumettez une requête de fonctionnalité sur la communauté des développeurs.

Contenu connexe

• Tâche Publier les résultats de la couverture du code
• Tâche Test Visual Studio
• Vérifier la qualité des builds