Couverture de test en Go : mesurer et améliorer la qualité du code

Comment mesurer la couverture de test en Go sans perdre la tête

Vous avez écrit des tests pour votre application Go. Vous vous sentez comme un super-héros ? Vous avez raison. Mais il y a un détail : quelle partie exacte du code est couverte par les tests ? Sans réponse à cette question, votre confiance n'est qu'une simple divination.

La question "How to measure test coverage in Go" est l'une des plus populaires sur Stack Overflow (des dizaines de milliers de vues). Et ce n'est pas un hasard. Les développeurs veulent non seulement écrire des tests, mais aussi comprendre leur efficacité. Dans ce tutoriel, nous allons aborder toutes les méthodes de mesure de la couverture de test en Go : des commandes de base aux techniques avancées avec profils et rapports HTML.

Qu'est-ce que la couverture de test et pourquoi la mesurer ?

La couverture de test (code coverage) est une métrique qui indique le pourcentage de votre code source exécuté pendant les tests. Elle s'exprime en pourcentage. 100% de couverture n'est pas toujours le Saint Graal, mais il vaut la peine de viser des scores élevés.

Pourquoi est-ce nécessaire ?

\n
• Contrôle qualité : vous voyez quelles parties du code restent sans tests
\n
• Confiance lors du refactoring : une couverture élevée réduit le risque de casser quelque chose
\n
• Métriques CI/CD : vous pouvez définir un seuil de couverture et bloquer le code avec une faible couverture
\n
• Documentation : les tests sont une documentation vivante, et la couverture montre à quel point elle est complète
\n

Piège : couverture ≠ qualité des tests

Rappelez-vous : 100% de couverture ne garantit pas l'absence de bugs. On peut écrire des tests qui appellent simplement des fonctions sans rien vérifier. La couverture est une métrique quantitative. La qualité des tests est qualitative. Utilisez les deux approches.

Mesure de base : go test -cover

Commençons par le plus simple. Go intègre la prise en charge de la couverture directement dans l'outil go test. Créons un projet simple et voyons comment cela fonctionne.

Créez le fichier math.go :

package main\n\nfunc Add(a, b int) int {\n    return a + b\n}\n\nfunc Subtract(a, b int) int {\n    return a - b\n}\n\nfunc Multiply(a, b int) int {\n    return a * b\n}\n\nfunc Divide(a, b int) (int, error) {\n    if b == 0 {\n        return 0, nil // Erreur : devrait être return 0, errors.New("division by zero")\n    }\n    return a / b, nil\n}

Et maintenant, le test (math_test.go) :

package main\n\nimport "testing"\n\nfunc TestAdd(t *testing.T) {\n    result := Add(2, 3)\n    if result != 5 {\n        t.Errorf("expected 5, got %d", result)\n    }\n}\n\nfunc TestSubtract(t *testing.T) {\n    result := Subtract(10, 4)\n    if result != 6 {\n        t.Errorf("expected 6, got %d", result)\n    }\n}\n\n// Volontairement, nous ne testons pas Multiply et Divide

Lançons maintenant les tests avec l'option -cover :

go test -cover

La sortie ressemblera à ceci :

ok      example/math    0.002s  coverage: 50.0% of statements

C'est exact — 50% du code est couvert, car Multiply et Divide ne sont pas testés. Mais ce n'est qu'un chiffre global. Et si nous voulions voir un profil de couverture détaillé ?

Profil de couverture : go test -coverprofile

L'option -coverprofile enregistre les informations détaillées sur la couverture dans un fichier :

go test -coverprofile=coverage.out

Maintenant, un fichier coverage.out est apparu dans le dossier. Ouvrez-le — c'est un format texte où chaque ligne indique si une instruction de code spécifique a été exécutée. Mais le lire manuellement est fastidieux. Passons à la visualisation.

Rapport HTML : go tool cover -html

La façon la plus pratique d'analyser la couverture est le rapport HTML. Il met en surbrillance le code exécuté en vert et le code non exécuté en rouge.

go tool cove