Alguém conseguiu gerar cobertura de código para testes de unidade Go? Não consigo encontrar uma ferramenta para isso na web.
Alguém conseguiu gerar cobertura de código para testes de unidade Go? Não consigo encontrar uma ferramenta para isso na web.
Respostas:
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 novogo tool cover
programa " " instalado separadamente , exibir os resultados da cobertura do teste .A
cover
ferramenta faz parte dogo.tools
subrepositó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-cover
sinalizador, 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.
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.out
e então
go tool cover -html=cover.out
abrecover.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 gc
e tenho uma lista de todas as linhas ainda não cobertas (aqui: com uma coverage.out
linha que não termina com " 1
").
go test -coverprofile cover.out
e, em seguida, go tool cover -html=cover.out -o cover.html
abra cover.html
no navegador
go tool cover -html=cover.out
abre automaticamente um navegador, mas não funciona no meu sistema. Prefiro manter um navegador aberto e atualizar a página, se necessário.
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 cd
entrar 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.
~/go/pkg/tool/linux_amd64
corresponde à minha última versão Go de ontem.
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.html
arquivo 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
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
go test -coverprofile <filename> <package name>