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.
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.
Réponses:
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 test
est qu'il peut désormais calculer et, avec l'aide d'un nouveaugo tool cover
programme " " installé séparément , afficher les résultats de la couverture des tests .L'
cover
outil fait partie du sous-go.tools
ré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'-cover
indicateur, 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.
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.out
puis
go tool cover -html=cover.out
s'ouvrecover.out
dans 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.out
ligne ne se terminant pas par " 1
").
go test -coverprofile cover.out
puis go tool cover -html=cover.out -o cover.html
ouvrir cover.html
dans le navigateur
go tool cover -html=cover.out
ouvrira 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.
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 -help
je 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, cd
dans 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.
~/go/pkg/tool/linux_amd64
correspond à ma dernière version Go d'hier.
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.html
fichier 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
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
Autre méthode
Couverture de test Go Native
go test -coverprofile=coverage.out
go tool cover -html=coverage.out
go test -coverprofile <filename> <package name>