Como medir a cobertura de código em Golang?

Alguém conseguiu gerar cobertura de código para testes de unidade Go? Não consigo encontrar uma ferramenta para isso na web.

Observe que o Go 1.2 (Q4 2013, rc1 está disponível) agora exibirá os resultados da cobertura do teste :

Um novo recurso importante do go testé que agora ele pode calcular e, com a ajuda de um novo go tool coverprograma " " instalado separadamente , exibir os resultados da cobertura do teste .

A coverferramenta faz parte do go.toolssubrepositório . Ele pode ser instalado executando

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

A ferramenta de cobertura faz duas coisas.

• Primeiro, quando " go test" recebe o -coversinalizador, ele é executado automaticamente para reescrever a fonte do pacote e inserir instruções de instrumentação. O teste é então compilado e executado normalmente, e as estatísticas básicas de cobertura são relatadas:

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

Em segundo lugar, para relatórios mais detalhados, diferentes sinalizadores para "ir testar" podem criar um arquivo de perfil de cobertura, que o programa de cobertura, chamado com " go tool cover", pode então analisar.

Frank Shearar menciona :

As versões mais recentes do Go (19/09/2013) usam:

go test -coverprofile <filename> <package name>

Detalhes sobre como gerar e analisar estatísticas de cobertura podem ser encontrados executando os comandos

$ go help testflag
$ go tool cover -help

Ivan Black menciona nos comentários :

go test -coverprofile cover.oute então
go tool cover -html=cover.outabrecover.out no seu navegador padrão

Não quero nem esperar que o navegador abra, então defini este alias:

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

Que acabei de digitar gce tenho uma lista de todas as linhas ainda não cobertas (aqui: com uma coverage.outlinha que não termina com " 1").

Go vem com uma ferramenta incrível para teste e cobertura. Embora todas as ferramentas Go sejam bem documentadas go tool cover -help, sugiro a leitura do artigo da história de capa no blog oficial Go . Tem muitos exemplos e eu recomendo fortemente!

Eu tenho essa função no meu ~ / .bash_profile. (você pode simplesmente colá-lo no terminal para tentar).

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

Em seguida, basta cdentrar em uma pasta de projeto / pacote go e digitarcover . Isso abre uma ferramenta visual no navegador que mostra o código testado e não testado para cada arquivo no pacote atual. Comando muito útil! Eu recomendo fortemente para encontrar o que ainda não foi 100% testado! Os resultados mostrados são por arquivo. Em uma lista suspensa no canto superior esquerdo, você pode ver os resultados de todos os arquivos.

Com este comando você também pode verificar a cobertura de qualquer pacote por exemplo:

cover fmt

A saída no terminal deste comando seria:

ok      fmt 0.031s  coverage: 91.9% of statements

Além disso, em seu navegador, você verá esta ferramenta mostrando em vermelho todas as linhas de código que não são cobertas por testes:

Também é possível apenas salvar o arquivo de cobertura html em vez de abri-lo em um navegador. Isso é muito útil nos casos em que seus testes + cobertura são executados por uma ferramenta de CI como o Jenkins. Dessa forma, você pode servir os arquivos de cobertura de um servidor central e toda a equipe poderá ver os resultados de cobertura de cada construção.

Além das boas respostas acima, considero estas três linhas a maneira mais simples de obtê-lo (o que inclui todos os pacotes):

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

Observe que no arquivo HTML você encontrará um botão suspenso que o direcionará para todos os arquivos.

Está bem aqui , alguns documentos aqui .

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

Eu não usei, isso é tudo que sei.

Se você gosta de ver as linhas descobertas por função diretamente em um terminal, reescrevi a ferramenta de capa para esse fim. Ele está disponível em https://github.com/gregoryv/uncover .

Uso

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

Captura de tela

Se você estiver usando o VSCode, esta funcionalidade é compatível com o uso imediato ( mas desativada por padrão )

Basta ativar o teste para salvar + relatório de cobertura

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

Ele até irá mostrar no seu editor quais linhas não foram cobertas, o que é muito útil.

Relatório de cobertura →

a) Execute todos os testes e habilite a cobertura -> go test ./... -coverprofile coverage.out

b) Obtenha cobertura para funções individuais, bem como cobertura geral → go tool cover -func coverage.out

c) Veja as linhas cobertas e as não cobertas pelos seus testes → go tool cover -html=cover.out -o coverage.html. Abra o coverage.htmlarquivo aqui gerado no navegador e analise as informações detalhadas da cobertura.

Uma maneira rápida e fácil é usar a ferramenta de cobertura que vem com o go integrado:

$ go test -coverprofile cp.out // Emite a cobertura em uma porcentagem do liner

Depois de executar o comando acima, se desejar ver visualmente a cobertura do código (como declarações cobertas e perdidas, etc.)

$ go tool cover -html = cp.out

Nota: Você precisa executar os comandos acima na pasta onde deseja ver a cobertura

Inspirado nos menus de ajuda e outras respostas a esta pergunta, basta executar:

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

Tente usar a imagem do Docker gaia-docker / base-go-build .

Esta é uma imagem Docker que contém tudo que você precisa para construir e testar a cobertura. A execução da cobertura de teste dentro de um contêiner Docker cria uma pasta .cover com os resultados da cobertura de teste de seu projeto.

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

O roteiro cobertura de teste em execução em todos os projetos de pastas e gera, dentro .Cobrir pasta relatórios JUnit e cobertura para cada pasta, e combinar relatório de cobertura de todos os projetos dos testes.

Codecov também sugere um script que coleta os resultados da cobertura: vários arquivos

Cobertura de teste para Golang

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

Verifique se está instalado corretamente e se você tem acesso a partir do seu terminal

Execute o caso de teste

Se você executar o caso de teste, ele rederirá o arquivo .json. Com base no arquivo, você obterá o relatório de cobertura de código no arquivo .html

gocov test >your_Coverage_report.json

Assim que seu caso de teste for concluído, gere um relatório em arquivo .html usando .json

gocov-html your_Coverage_report.json >your_Coverage_report.html

Referência

Ferramenta de cobertura GoTest para go lang

Ferramenta de relatório de teste Go

Método Alternativo

Cobertura de teste Go Native

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