Comment mesurer la couverture de code dans Golang?

Quelqu'un a-t-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) 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").

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:

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.

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.

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.

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

Si vous utilisez VSCode, cette fonctionnalité est prise en charge par défaut ( mais désactivée par défaut )

Activez simplement le test sur les rapports Enregistrer + couverture

https://github.com/microsoft/vscode-go/wiki/On-Save-features

Il montrera même dans votre éditeur quelles lignes ne sont pas couvertes, ce qui est très pratique.

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.

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

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

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

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