Azure DevOps et la couverture de code

Bien que Microsoft propose une solution pour calculer nativement la couverture de code, elle génère plusieurs problèmes : différence de résultats entre le Build Server et “Visual Studio / Test / Analyze Code coverage”, problème de couverture de code des assemblies référencés, etc.

Azure DevOps

La procédure suivante à l’avantage d’être simple et facilement vérifiable localement. Pour mettre en place des tests unitaires, pour un projet .NET Core, dans Azure DevOps, il faut :

1. Dans votre solution Visual Studio, ajouter un projet de tests unitaires (dont le nom de termine par Tests).

2. Référencer le package Nuget coverlet.msbuild qui sera utilisé en extension de la commande dotnet test utilisé plus loin.

3. Dans le Pipeline Build de Azure DevOps, ajouter une tâche .NET Core pour exécuter les tests unitaires et pour récolter les données sur la couverture de code (via coverlet). Cette tâche génèrera un fichier coverage.cobertura.xml dans le dossier du projet de test, au format Cobertura qui est supporté par Azure DevOps.

   • Commande : Test
   • Path to projet(s) : **/*[Tt]ests/*.csproj
   • Arguments : --configuration $(BuildConfiguration) /p:CollectCoverage=true /p:CoverletOutputFormat=cobertura
   • Publish test results and code coverage : cochée

4. Via le Marketplace, ajouter l’extension ReportGenerator (de Palmmedia) et cette tâche dans votre Pipeline :

   • Reports : **/coverage.cobertura.xml
   • Target directory : CoverageReport
   • Report types: HtmlInline_AzurePipelines;Cobertura

   Cette tâche génèrera un rapport HTML du code coverage (supporté par Azure), dans le dossier /CoverageReport.

5. Ajouter une tâche Publish code coverage results pour publier le rapport HTML dans un onglet Coverage du Build Summary.

   • Code coverage tool : Cobertura
   • Summary file : **/coverage.cobertura.xml
   • Report dyrectory : CoverageReport

Résultats

Une fois le Build exécuté, l’onglet Summary affiche les statistiques des tests unitaires et de la couverture de code. L’onglet Code Coverage présente un rapport complet de la couverture de code, y compris les parties de code non couvertes.

Localement

Vous pouvez exécuter un Code Coverage localement, en utilisant l’outil coverlet.console .NET Core Global Tools est très utile pour disposer rapidement d’un outil efficace pour les développeurs. Vous devez disposer de .NET Core SDK et Nate McMaster en a référencé plusieurs intéressants sur son GitHub.

• Installer l’outil via : dotnet tool install --global coverlet.console
• Depuis votre projet de tests, exécuter un Code Coverage : dotnet test /p:CollectCoverage=true

Exemple :

$] dotnet test /p:CollectCoverage=true

Build started, please wait...
Build completed.

Test run for ...(.NETCoreApp,Version=v2.2)
Microsoft (R) Test Execution Command Line Tool Version 15.9.0
Copyright (c) Microsoft Corporation.  All rights reserved.

Starting test execution, please wait...

Total tests: 10. Passed: 10. Failed: 0. Skipped: 0.
Test Run Successful.
Test execution time: 0.7909 Seconds

Calculating coverage result...
Generating report 'coverage.json'

+--------------------+-------+--------+--------+
| Module             | Line  | Branch | Method |
+--------------------+-------+--------+--------+
| Services.Data      | 78.1% | 66.1%  | 90.3%  |
+--------------------+-------+--------+--------+
| Services.Scrappers | 96.4% | 50%    | 100%   |
+--------------------+-------+--------+--------+
| ScrappersTests     | 89.8% | 92.3%  | 92.6%  |
+--------------------+-------+--------+--------+

+---------+-------------------+--------+-------------------+
|         | Line              | Branch | Method            |
+---------+-------------------+--------+-------------------+
| Total   | 85.7%             | 73.8%  | 92.2%             |
+---------+-------------------+--------+-------------------+
| Average | 28.5666666666667% | 24.6%  | 30.7333333333333% |
+---------+-------------------+--------+-------------------+

Limite minimale de couverture

Il est fréquent d’obliger les développeurs à atteindre une couverture de code d’au moins 80%. Pour cela, il faut choisir son critère et son seuil minimal. Par exemple, pour au moins 80% de couverture total des lignes de code, il faut ajouter ces paramètres threshold (à la commande locale ou aux arguments Azure DevOps).

dotnet test /p:CollectCoverage=true /p:threshold=80 /p:thresholdType=line /p:thresholdStat=total