Come misurare la copertura del codice a Golang?

Qualcuno è riuscito a generare la copertura del codice per gli unit test Go? Non riesco a trovare uno strumento per questo sul web.

Tieni presente che Go 1.2 (Q4 2013, rc1 è disponibile) ora mostrerà i risultati della copertura del test :

Una delle novità principali di go testè che ora può calcolare e, con l'aiuto di un nuovo go tool coverprogramma " " installato separatamente , visualizzare i risultati della copertura dei test .

Lo coverstrumento fa parte del go.toolssottorepository . Può essere installato eseguendo

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

Lo strumento copertina fa due cose.

• Per prima cosa, quando " go test" viene assegnato il -coverflag, viene eseguito automaticamente per riscrivere il sorgente per il pacchetto e inserire le istruzioni della strumentazione. Il test viene quindi compilato ed eseguito come al solito e vengono riportate le statistiche di copertura di base:

$ go test -coverprofile fmtcoverage.html fmt
ok      fmt 0.060s  coverage: 91.4% of statements
$

In secondo luogo, per rapporti più dettagliati, diversi flag per "go test" possono creare un file del profilo di copertura, che il programma di copertura, invocato con " go tool cover", può quindi analizzare.

Frank Shearar menziona :

Le ultime versioni di Go (2013/09/19) utilizzano:

go test -coverprofile <filename> <package name>

I dettagli su come generare e analizzare le statistiche di copertura possono essere trovati eseguendo i comandi

$ go help testflag
$ go tool cover -help

Ivan Black menziona nei commenti :

go test -coverprofile cover.oute quindi si
go tool cover -html=cover.outapre cover.outnel browser predefinito

Non voglio nemmeno aspettare che il browser si apra, quindi ho definito questo alias:

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

Ho appena digitato gce ho un elenco di tutte le righe non ancora coperte (qui: con una coverage.outriga che non termina con " 1").

Go viene fornito con uno strumento fantastico per test e copertura. Sebbene tutti gli strumenti Go siano ben documentati go tool cover -help, suggerirei di leggere l'articolo di copertina sul blog ufficiale di Go . Ha molti esempi e lo consiglio vivamente!

Ho questa funzione nel mio ~ / .bash_profile. (puoi semplicemente incollarlo nel terminale per provarlo).

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

Quindi basta cdin una cartella go project / package e digita cover. Questo apre uno strumento visivo nel browser che mostra il codice testato e non testato per ogni file nel pacchetto corrente. Comando molto utile! Lo consiglio vivamente per trovare ciò che non è ancora testato al 100%! I risultati visualizzati sono per file. Da un menu a discesa in alto a sinistra puoi vedere i risultati per tutti i file.

Con questo comando puoi anche controllare la copertura di qualsiasi pacchetto ad esempio:

cover fmt

L'output nel terminale da questo comando sarebbe:

ok      fmt 0.031s  coverage: 91.9% of statements

Oltre a ciò nel tuo browser vedrai questo strumento mostrare in rosso tutte le righe di codice che non sono coperte dai test:

È anche possibile salvare semplicemente il file di copertura html invece di aprirlo in un browser. Ciò è molto utile nei casi in cui i test + la copertura vengono eseguiti da uno strumento CI come Jenkins. In questo modo puoi servire i file di copertura da un server centrale e l'intero team sarà in grado di vedere i risultati di copertura per ogni build.

Oltre alle buone risposte sopra, trovo che queste tre righe siano il modo più semplice per ottenerlo (che include tutti i pacchetti):

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

Nota che nel file HTML troverai un pulsante a discesa che ti indirizzerà a tutti i file.

È proprio qui , alcuni documenti qui .

$ 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
$

Non l'ho usato, questo è tutto quello che so.

Se ti piace vedere le linee scoperte per funzione direttamente in un terminale ho riscritto lo strumento copertina per questo scopo. È disponibile su https://github.com/gregoryv/uncover .

uso

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

Immagine dello schermo

Se stai usando VSCode questa funzionalità è supportata immediatamente ( ma disabilitata per impostazione predefinita )

Basta attivare il test su salvataggio + report di copertura

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

Mostrerà anche nel tuo editor quali righe non sono coperte, il che è molto utile.

Rapporto di copertura →

a) Eseguire tutti i test e abilitare la copertura -> go test ./... -coverprofile coverage.out

b) Ottieni la copertura per le singole funzioni e la copertura complessiva → go tool cover -func coverage.out

c) Vedi le linee coperte e quelle non coperte dai tuoi test → go tool cover -html=cover.out -o coverage.html. Aprire il coverage.htmlfile qui generato nel browser e analizzare le informazioni dettagliate sulla copertura.

Un modo semplice e veloce è utilizzare lo strumento di copertura fornito con go integrato:

$ go test -coverprofile cp.out // Emette la copertura in percentuale di una riga

Dopo aver eseguito il comando precedente, se desideri vedere visivamente la copertura del codice (come istruzioni coperte e mancate ecc.)

$ go tool cover -html = cp.out

Nota: è necessario eseguire i comandi precedenti nella cartella in cui si desidera visualizzare la copertura

Ispirato dai menu della guida e da altre risposte a questa domanda, esegui:

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

Prova a utilizzare gaia-docker / base-go-build Docker Image.

Questa è un'immagine Docker che contiene tutto ciò di cui hai bisogno per creare e testare la copertura. L'esecuzione della copertura del test all'interno di un contenitore Docker crea la cartella .cover con i risultati della copertura del test del progetto.

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

Lo script di copertura del test viene eseguito su tutte le cartelle dei progetti e viene generato, all'interno di .cover cartella .cover junit, i report di copertura per ciascuna cartella e un report di copertura combinato dei test di tutti i progetti.

Codecov suggerisce anche uno script che raccoglie i risultati della copertura: più file

Copertura del test per Golang

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

Controlla che sia installato correttamente e di avere accesso dal tuo terminale

Esegui il test case

Se esegui il test case, il file .json verrà reimpostato in base al file, otterrai il rapporto sulla copertura del codice nel file .html

gocov test >your_Coverage_report.json

Una volta terminato lo scenario di test, genera un rapporto in file .html utilizzando .json

gocov-html your_Coverage_report.json >your_Coverage_report.html

Riferimento

Strumento di copertura GoTest per go lang

Go Test Report Tool

Metodo alternativo

Vai alla copertura del test nativo

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