web-dev-qa-db-fra.com

Comment mesurer la couverture de code dans Golang?

Quelqu'un at-il réussi à générer une couverture de code pour les tests unitaires Go? Je ne trouve pas d’outil pour cela sur le Web.

84
George Atsev

Notez que Go 1.2 (Q4 2013, rc1 est disponible) va maintenant afficher résultats de la couverture de test :

Une nouvelle fonctionnalité majeure de go test Est qu'il peut désormais calculer et, avec l'aide d'un nouveau programme "go tool cover" Installé séparément, afficher les résultats de la couverture de test .

L'outil cover fait partie du sous-répertoire go.tools . Il peut être installé en exécutant

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

L'outil de couverture fait deux choses.

  • Tout d'abord, lorsque l'indicateur go test Est attribué à "-cover", 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 les 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 à "tester" peuvent créer un fichier de profil de couverture, que le programme de couverture, appelé avec "go tool cover", Peut ensuite analyser.

Frank Sheararmentions :

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

go test -coverprofile <filename> <package name>

Vous pouvez trouver des détails sur la manière de générer et d’analyser des statistiques de couverture en exécutant les commandes.

$ go help testflag
$ go tool cover -help

Ivan Black mentionne dans les commentaires :

go test -coverprofile cover.out Puis
go tool cover -html=cover.out -o cover.html Ouvre cover.html Dans le navigateur

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

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

Que je viens de taper gc, et d'avoir une liste de toutes les lignes pas encore couverte (ici: avec une ligne coverage.out pas se terminant par "1").

101
VonC

Go est livré avec un excellent outil de test et de couverture. Bien que tous les outils Go soient bien documentés go tool cover -help Je suggérerais de lire L'article de couverture sur le blog officiel Go . Il a beaucoup d'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, il suffit de placer cd dans un dossier de projet/package et de saisir 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 fortement pour trouver ce qui n'est pas encore testé à 100%! Les résultats affichés sont par fichier. Dans 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 tout package, 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 afficher en rouge toutes les lignes de code qui ne sont pas couvertes par les tests:

enter image description here

Il est également possible de simplement sauvegarder le fichier de couverture html au lieu de l’ouvrir dans un navigateur. Ceci est très utile dans les cas où vos tests + la couverture est exécutée par un outil de CI tel que Jenkins. De cette façon, vous pouvez servir les fichiers de couverture à partir d'un serveur central et toute l'équipe sera en mesure de voir les résultats de couverture pour chaque génération.

32
Pavel Nikolov

C'est vrai ici , des 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.

5
zzzz

En plus des bonnes réponses ci-dessus, je trouve que ces trois lignes sont le moyen le plus simple de l'obtenir (qui inclut 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.

4
Sharon Katz

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

Utilisation

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

Capture d'écran

enter image description here

2
dot7

Inspiré par les menus d'aide et d'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
1
030

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

$ go test -coverprofile cp.out // Emet la couverture en pourcentage du liner

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

couverture de l'outil $ go -html = cp.out

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

Essayez d’utiliser gaia-docker/base-go-build Image Docker.

Ceci est 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 à l'intérieur d'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écute sur tous les dossiers de projets et génère, à l'intérieur . Couverture dossier junit et des rapports de couverture pour chaque dossier, ainsi qu'un rapport de couverture de couverture de tous les projets tests.

Codecov suggère également un script qui collecte les résultats de couverture: plusieurs fichiers

0
Effi Bar-She'an

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 à partir de votre terminal

Exécuter 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 de code dans un fichier .html.

gocov test >your_Coverage_report.json

Une fois que votre scénario de test est terminé Générez un rapport dans un fichier .html en utilisant .json

gocov-html your_Coverage_report.json >your_Coverage_report.html

Référence

Outil de couverture GoTest pour go lang

Go Test Report Tool

Méthode alternative

Aller à la couverture de test natif

go test -coverprofile=coverage.out
go tool cover -html=coverage.out
0
muthukumar