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.
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 testEst 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
coverfait partie du sous-répertoirego.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 testEst 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.
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.outPuisgo tool cover -html=cover.out -o cover.htmlOuvrecover.htmlDans 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").
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:
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.
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.
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.
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
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
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
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
Méthode alternative
Aller à la couverture de test natif
go test -coverprofile=coverage.out
go tool cover -html=coverage.out