Comment mesurer la couverture de code dans Golang?


Réponses:


138

Notez que Go 1.2 (Q4 2013, rc1 est disponible) affichera désormais les résultats de la couverture des tests :

Une nouveauté majeure de go testest qu'il peut désormais calculer et, avec l'aide d'un nouveau go tool coverprogramme " " installé séparément , afficher les résultats de la couverture des tests .

L' coveroutil fait partie du sous- go.toolsréférentiel . Il peut être installé en exécutant

$ go get golang.org/x/tools/cmd/cover

L'outil de couverture fait deux choses.

  • Premièrement, lorsque " go test" reçoit l' -coverindicateur, il est exécuté automatiquement pour réécrire la source du paquet et insérer des instructions d'instrumentation. Le test est ensuite compilé et exécuté comme d'habitude, et des statistiques de couverture de base sont rapportées:
$ go test -coverprofile fmtcoverage.html fmt
ok      fmt 0.060s  coverage: 91.4% of statements
$

Deuxièmement, pour des rapports plus détaillés, différents indicateurs de "go test" peuvent créer un fichier de profil de couverture, que le programme de couverture, appelé avec " go tool cover", peut ensuite analyser.

Frank Shearar mentionne :

Les dernières versions de Go (2013/09/19) utilisent:

go test -coverprofile <filename> <package name>

Des détails sur la façon de générer et d'analyser les statistiques de couverture peuvent être trouvés en exécutant les commandes

$ go help testflag
$ go tool cover -help

Ivan Black mentionne dans les commentaires :

go test -coverprofile cover.outpuis
go tool cover -html=cover.outs'ouvre cover.outdans votre navigateur par défaut

Je ne veux même pas attendre que le navigateur s'ouvre, j'ai donc défini cet alias:

alias gc=grep -v -e " 1$" cover.out

Que je viens de taper gc, et avoir une liste de toutes les lignes non encore couvertes (ici: avec une coverage.outligne ne se terminant pas par " 1").


2
Notez que les dernières versions de Go (2013/09/19) utilisentgo test -coverprofile <filename> <package name>
Frank Shearar

@FrankShearar Ok. J'ai inclus votre commentaire dans la réponse pour plus de visibilité.
VonC

go test -coverprofile cover.outpuis go tool cover -html=cover.out -o cover.htmlouvrir cover.htmldans le navigateur
Ivan Black

@IvanBlack bon point. Je l'ai inclus dans la réponse pour plus de visibilité. J'ai également ajouté un alias que j'utilise pour voir rapidement les lignes non couvertes.
VonC

1
@VonC go tool cover -html=cover.outouvrira automatiquement un navigateur, mais cela ne fonctionne pas pour mon système. Je préfère garder un navigateur ouvert et actualiser la page si nécessaire.
Ivan Black

41

Go est livré avec un outil génial pour les tests et la couverture. Bien que tous les outils Go soient bien documentés, go tool cover -helpje suggère de lire l' article de couverture sur le blog officiel de Go . Il contient de nombreux exemples et je le recommande vivement!

J'ai cette fonction dans mon ~ / .bash_profile. (vous pouvez simplement le coller dans le terminal pour l'essayer).

cover () { 
    t="/tmp/go-cover.$$.tmp"
    go test -coverprofile=$t $@ && go tool cover -html=$t && unlink $t
}

Ensuite, cddans un dossier de projet / package go et tapez cover. Cela ouvre un outil visuel dans le navigateur qui vous montre le code testé et non testé pour chaque fichier du package actuel. Commande très utile! Je le recommande vivement pour trouver ce qui n'est pas encore testé à 100%! Les résultats affichés sont par fichier. À partir d'une liste déroulante en haut à gauche, vous pouvez voir les résultats pour tous les fichiers.

Avec cette commande, vous pouvez également vérifier la couverture de n'importe quel paquet, par exemple:

cover fmt

La sortie dans le terminal de cette commande serait:

ok      fmt 0.031s  coverage: 91.9% of statements

En plus de cela dans votre navigateur, vous verrez cet outil montrant en rouge toutes les lignes de code qui ne sont pas couvertes par les tests:

entrez la description de l'image ici

Il est également possible de simplement enregistrer le fichier de couverture html au lieu de l'ouvrir dans un navigateur. Ceci est très utile dans les cas où vos tests + couverture sont exécutés par un outil CI comme Jenkins. De cette façon, vous pouvez servir les fichiers de couverture à partir d'un serveur central et toute l'équipe pourra voir les résultats de couverture pour chaque build.



Intéressant, je vais le tester. +1
VonC

C'est génial! Merci d'avoir partagé. J'ai fini par passer à un script de test car je voulais tester un package principal dans mon programme. Cheers
James O'Toole

11

En plus des bonnes réponses ci-dessus, je trouve que ces trois lignes sont le moyen le plus simple de l'obtenir (qui comprend tous les packages):

go test -v -coverprofile cover.out ./YOUR_CODE_FOLDER/...
go tool cover -html=cover.out -o cover.html
open cover.html

Notez que dans le fichier HTML, vous trouverez un bouton déroulant qui vous dirigera vers tous les fichiers.


5

C'est juste ici , quelques documents ici .

$ go tool
6a
6c
6g
6l
addr2line
api
cgo
cov
dist
ebnflint
fix
gotype
nm
objdump
pack
pprof
prof
vet
yacc
$ go tool cov -h
usage: cov [-lsv] [-g substring] [-m minlines] [6.out args...]
-g specifies pattern of interesting functions or files
go tool cov: exit status 1
$

Je ne l'ai pas utilisé, c'est tout ce que je sais.


devez-vous l'installer manuellement? dans mon installation go locale (go version go1) il n'est pas là.
oers

Je crois qu'il est construit par ./all.bash. Je ne peux pas vérifier ATM, je ne suis pas à la sortie car j'ai un CL en attente, mais l'horodatage binaire cov que je vois dans ~/go/pkg/tool/linux_amd64correspond à ma dernière version Go d'hier.
zzzz

Oui, exécutez ./all.bash et vous l'aurez. Merci pour l'aide, jnml!
George Atsev

J'ai quelques problèmes pour l'exécuter sur ma machine x86. J'ai essayé de changer main.c comme mentionné dans ce fil: groups.google.com/group/golang-dev/browse_thread/thread / ... Mais cela génère une erreur d'exécution dans un autre emplacement. Je vais l'essayer sur une machine 64 bits.
George Atsev

3

Si vous aimez voir les lignes découvertes par fonction directement dans un terminal, j'ai réécrit l'outil de couverture à cet effet. Il est disponible sur https://github.com/gregoryv/uncover .

Usage

go get -u github.com/gregoryv/uncover/...
go test -coverprofile /tmp/c.out
uncover /tmp/c.out

Capture d'écran

entrez la description de l'image ici



2

Rapport de couverture →

a) Exécutez tous les tests et activez la couverture -> go test ./... -coverprofile coverage.out

b) Obtenez une couverture pour les fonctions individuelles ainsi qu'une couverture globale → go tool cover -func coverage.out

c) Voir les lignes couvertes et celles non couvertes par vos tests → go tool cover -html=cover.out -o coverage.html. Ouvrez le coverage.htmlfichier ainsi généré dans le navigateur et analysez les informations détaillées de couverture.


1

Un moyen simple et rapide consiste à utiliser l'outil de couverture fourni avec go intégré:

$ go test -coverprofile cp.out // Émet la couverture en une seule ligne en pourcentage

Après avoir exécuté la commande ci-dessus, si vous souhaitez voir visuellement la couverture du code (comme les déclarations couvertes et manquées, etc.)

$ go tool cover -html = cp.out

Remarque: vous devez exécuter les commandes ci-dessus dans le dossier où vous souhaitez voir la couverture


1

Inspiré par les menus d'aide et autres réponses à cette question, lancez simplement:

f=cover.out; if [ -f $f ]; then rm $f; fi; go test ./... -coverprofile $f && \
go tool cover -html $f && \
rm $f

0

Essayez d'utiliser l' image Docker gaia-docker / base-go-build .

Il s'agit d'une image Docker qui contient tout ce dont vous avez besoin pour créer et tester la couverture. L'exécution de la couverture de test dans un conteneur Docker crée un dossier .cover avec les résultats de la couverture de test de votre projet.

docker run --rm -v "$PWD":$PROJECT_PATH -w $PROJECT_PATH $BUILDER_IMAGE_NAME /go/script/coverage.sh

Le script de couverture de test s'exécutant sur les dossiers de tous les projets et génère, à l'intérieur du dossier .cover, des rapports junit et de couverture pour chaque dossier, et un rapport de couverture combinée de tous les tests de projets.

Codecov propose également un script qui collecte les résultats de la couverture: plusieurs fichiers


-1

Couverture de test pour Golang

go get github.com/axw/gocov/gocov go get -u gopkg.in/matm/v1/gocov-html

Vérifiez qu'il est correctement installé et que vous avez accès depuis votre terminal

Exécutez le scénario de test

Si vous exécutez le scénario de test, le fichier .json sera redéfini. En fonction du fichier, vous obtiendrez le rapport de couverture du code dans un fichier .html

gocov test >your_Coverage_report.json

Une fois votre scénario de test terminé, générez un rapport dans un fichier .html à l'aide de .json

gocov-html your_Coverage_report.json >your_Coverage_report.html

Référence

Outil de couverture GoTest pour go lang

Outil de rapport de test Go

Autre méthode

Couverture de test Go Native

go test -coverprofile=coverage.out
go tool cover -html=coverage.out
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.