¿Cómo medir la cobertura del código en Golang?

¿Alguien ha logrado generar cobertura de código para las pruebas unitarias de Go? No puedo encontrar una herramienta para eso en la web.

Tenga en cuenta que Go 1.2 (Q4 2013, rc1 está disponible) ahora mostrará los resultados de cobertura de prueba :

Una característica nueva importante de go testes que ahora puede calcular y, con la ayuda de un nuevo go tool coverprograma " " instalado por separado , mostrar los resultados de la cobertura de la prueba .

La coverherramienta es parte del go.toolssubrepositorio . Se puede instalar ejecutando

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

La herramienta de portada hace dos cosas.

• Primero, cuando " go test" recibe el -coverindicador, se ejecuta automáticamente para reescribir el código fuente del paquete e insertar instrucciones de instrumentación. Luego, la prueba se compila y ejecuta como de costumbre, y se informan las estadísticas de cobertura básicas:

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

En segundo lugar, para informes más detallados, diferentes banderas para "ir a prueba" pueden crear un archivo de perfil de cobertura, que el programa de cobertura, invocado con " go tool cover", puede analizar.

Frank Shearar menciona :

Las últimas versiones de Go (2013/09/19) utilizan:

go test -coverprofile <filename> <package name>

Los detalles sobre cómo generar y analizar estadísticas de cobertura se pueden encontrar ejecutando los comandos

$ go help testflag
$ go tool cover -help

Ivan Black menciona en los comentarios :

go test -coverprofile cover.outy luego se
go tool cover -html=cover.outabre cover.outen su navegador predeterminado

Ni siquiera quiero esperar a que se abra el navegador, así que definí este alias:

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

Eso solo lo escribo gcy tengo una lista de todas las líneas que aún no se han cubierto (aquí: con una coverage.outlínea que no termina en " 1").

Go viene con una herramienta increíble para pruebas y cobertura. Aunque todas las herramientas de Go están bien documentadas go tool cover -help, sugeriría leer el artículo de la portada en el blog oficial de Go . Tiene muchos ejemplos y lo recomiendo encarecidamente.

Tengo esta función en mi ~ / .bash_profile. (puede pegarlo en la terminal para probarlo).

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

Luego solo cden una carpeta de proyecto / paquete go y escriba cover. Esto abre una herramienta visual en el navegador que le muestra el código probado y no probado para cada archivo en el paquete actual. ¡Comando muy útil! ¡Lo recomiendo encarecidamente para encontrar lo que aún no está probado al 100%! Los resultados mostrados son por archivo. Desde un menú desplegable en la parte superior izquierda puede ver los resultados de todos los archivos.

Con este comando también puede verificar la cobertura de cualquier paquete por ejemplo:

cover fmt

La salida en la terminal de este comando sería:

ok      fmt 0.031s  coverage: 91.9% of statements

Además de eso, en su navegador verá esta herramienta mostrando en rojo todas las líneas de código que no están cubiertas con pruebas:

También es posible guardar el archivo de cobertura html en lugar de abrirlo en un navegador. Esto es muy útil en los casos en que sus pruebas + cobertura se ejecutan mediante una herramienta de CI como Jenkins. De esa manera, puede servir los archivos de cobertura desde un servidor central y todo el equipo podrá ver los resultados de cobertura para cada compilación.

Además de las buenas respuestas anteriores, creo que estas tres líneas son la forma más sencilla de obtenerlo (que incluye todos los paquetes):

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

Tenga en cuenta que en el archivo HTML encontrará un botón desplegable que lo dirigirá a todos los archivos.

Está aquí mismo , algunos documentos aquí .

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

No lo he usado, esto es todo lo que sé.

Si desea ver las líneas descubiertas por función directamente en un terminal, reescribí la herramienta de portada para este propósito. Está disponible en 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 pantalla

Si está utilizando VSCode, esta funcionalidad es compatible desde el primer momento ( pero deshabilitada de forma predeterminada )

Simplemente active la prueba en los informes de guardado + cobertura

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

Incluso mostrará en su editor qué líneas no están cubiertas, lo cual es muy útil.

Informe de cobertura →

a) Ejecute todas las pruebas y habilite la cobertura -> go test ./... -coverprofile coverage.out

b) Obtenga cobertura para funciones individuales así como cobertura general → go tool cover -func coverage.out

c) Vea las líneas cubiertas y las no cubiertas por sus pruebas → go tool cover -html=cover.out -o coverage.html. Abra el coverage.htmlarchivo generado en el navegador y analice la información detallada de la cobertura.

Una forma rápida y sencilla es utilizar la herramienta de cobertura que viene con go integrado:

$ go test -coverprofile cp.out // Emite la cobertura en un porcentaje porcentual

Después de ejecutar el comando anterior, si desea ver visualmente la cobertura del código (como declaraciones cubiertas y omitidas, etc.)

$ go cubierta de la herramienta -html = cp.out

Nota: debe ejecutar los comandos anteriores en la carpeta donde desea ver la cobertura

Inspirado por los menús de ayuda y otras respuestas a esta pregunta, simplemente ejecute:

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

Intente usar gaia-docker / base-go-build Docker Image.

Esta es una imagen de Docker que contiene todo lo que necesita para crear y probar la cobertura. La ejecución de la cobertura de prueba dentro de un contenedor de Docker crea una carpeta .cover con los resultados de la cobertura de prueba de su proyecto.

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

El script de cobertura de la prueba que se ejecuta en todos los proyectos de carpetas y genera, en el interior .Cubrir carpeta de informes junit y cobertura para cada carpeta y un informe de combinar la cobertura de todos los proyectos de pruebas.

Codecov también sugiere un script que recopila los resultados de la cobertura: varios archivos

Cobertura de prueba para Golang

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

Verifique que esté instalado correctamente y que tenga acceso desde su Terminal

Ejecutar el caso de prueba

Si ejecuta el caso de prueba, leerá el archivo .json. Según el archivo, obtendrá el Informe de cobertura de código en un archivo .html.

gocov test >your_Coverage_report.json

Una vez que haya terminado su caso de prueba, genere un informe en un archivo .html usando .json

gocov-html your_Coverage_report.json >your_Coverage_report.html

Referencia

Herramienta de cobertura GoTest para go lang

Ir a la herramienta de informe de prueba

Metodo alternativo

Ir a cobertura de prueba nativa

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