Una introducción a las pruebas en Go

Las pruebas son muy importantes en todo el software. Ser capaz de garantizar la corrección de su código y asegurarse de que los cambios que realice no terminen rompiendo nada más en diferentes partes de su base de código es muy importante.

Al tomarse el tiempo para probar adecuadamente sus programas go, se permite desarrollar más rápido con una mayor sensación de confianza de que lo que está desarrollando continuará funcionando cuando lo lance a producción.

Objetivos

Al final de este tutorial, tendrá una buena comprensión de probar funciones y métodos básicos en Go utilizando el paquete estándar "testing".

Habrá tenido experiencia en pruebas de escritura en mesa y también verá cómo generar una salida más detallada de sus pruebas utilizando las diversas marcas disponibles.

Video Tutorial

Este tutorial se puede encontrar en formato de video si lo prefiere:

Introducción

En este tutorial veremos cómo puede desarrollar y ejecutar pruebas para su código go utilizando el comando go test.

Archivos de prueba Go

Si ha visto algún proyecto go antes, es posible que haya notado que la mayoría, si no todos los archivos dentro del proyecto, cuentan con una contraparte FILE_test.go dentro del mismo directorio.

Esto no es un accidente. Estos son los archivos que contienen todas las pruebas unitarias para el proyecto y prueban todo el código dentro de sus contrapartes.

myproject/- calc.go- calc_test.go- main.go- main_test.go

Un archivo de prueba simple

Imagine que teníamos un programa go muy simple que se componía de un archivo y tenía una función calculate(). Esta función calculate() simplemente toma 1 número y le agrega 2. Agradable y sencillo para ponernos en marcha:

Si quisiéramos probar esto, podríamos crear un archivo main_test.go dentro del mismo directorio y escribir la siguiente prueba:

package mainimport ( "testing")func TestCalculate(t *testing.T) { if Calculate(2) != 4 { t.Error("Expected 2 + 2 to equal 4") }}

Ejecutar nuestras pruebas

Ahora que hemos creado nuestra primera prueba de go, es hora de ejecutar esto y ver si nuestro código se comporta de la manera que esperamos. Podemos ejecutar nuestras pruebas ejecutando:

$ go test

Esto debería generar algo similar a lo siguiente:

PASSok _/Users/elliot/Documents/Projects/tutorials/golang/go-testing-tutorial 0.007s

Pruebas basadas en tablas

Ahora que estamos contentos de que un cálculo funcione, deberíamos buscar mejorar la confianza agregando algunos casos de prueba adicionales a nuestro código. Si queremos construir de forma tradicional una serie de casos de prueba que siempre se prueban, podemos apalancar un array de pruebas como:

Aquí declaramos una estructura que contiene tanto una entrada como el valor esperado. Luego, repasamos la lista de pruebas con nuestra llamada for _, test := range testsy comprobamos que nuestra función siempre devolverá los resultados esperados, independientemente de la entrada.

Cuando ejecutamos nuestro conjunto de pruebas ahora, deberíamos ver la misma salida que antes:

PASSok _/Users/elliot/Documents/Projects/tutorials/golang/go-testing-tutorial 0.007s

Salida de prueba detallada

A veces es posible que desee ver exactamente qué pruebas se están ejecutando y cuánto tiempo duran. Afortunadamente, esto está disponible si usa la bandera -v al ejecutar sus pruebas de la siguiente manera:

Puede ver que tanto nuestra prueba normal como nuestra prueba de tabla se ejecutaron y pasaron y sin took que 0.00s para ejecutarse.

Comprobar la cobertura de prueba

La cobertura de prueba es una métrica que he visto abusada a veces por las empresas. Estas empresas establecen objetivos en todos sus sistemas, como «el código base debe estar cubierto al menos en un 75% por pruebas».

Pero este tipo de objetivos puede llevar a un comportamiento deficiente y a que los equipos de desarrollo «jueguen»con el sistema para intentar alcanzar estos objetivos. He visto a personas en algunos equipos escribir pruebas unitarias que prueban getters y setters básicos en idiomas como Java.

Las pruebas son muy importantes, pero debe ser pragmático sobre cómo probar sus sistemas para que las pruebas que escriba le proporcionen el mayor valor.

Los días dedicados a escribir pruebas para cubrir partes sin importancia de su base de código podrían haberse dedicado mejor a escribir casos de prueba en torno al logic de negocios crítico dentro de sus sistemas y garantizar que se cubran más casos de borde.

Usando la bandera-cover

Con la parte importante fuera del camino, veamos cómo puede verificar la cobertura de prueba de su sistema utilizando el comando go test:

Dentro del mismo directorio que sus archivos main.go y main_test.go, ejecute lo siguiente:

PASScoverage: 66.7% of statementsok github.com/TutorialEdge/an-intro-to-testing-in-go 0.006s

Verá que tiene 66.7% de su código Go total cubierto por los casos de prueba.

Visualización de cobertura

Si bien este valor 66.7% puede decirnos cuánto código hemos probado, no nos muestra exactamente qué rutas de código tenemos o no hemos probado.

Aquí es donde el go test y el go tool cover nos ayudan a resolver este problema en particular.

Podemos usar la herramienta go test para generar un coverprofile que luego se puede convertir en una visualización HTML utilizando el comando go tool cover:

PASScoverage: 66.7% of statementsok github.com/TutorialEdge/an-intro-to-testing-in-go 0.008s

Luego puede tomar este archivo coverage.out generado y usarlo para generar una página HTML que muestra exactamente qué líneas se han cubierto de esta manera:

$ go tool cover -html=coverage.out

Esto abrirá una página en su navegador de elección que se verá como una pequeña cosa como esta:

Como puede ver, la mayor parte del código dentro de nuestra función Calculate está probando y presenta cobertura Green. Mientras que la instrucción print en su función main es Red, ya que esto no ha sido cubierto por las pruebas.

Conclusión

¡Esperamos que haya encontrado este tutorial útil! Si necesita más ayuda, no dude en hacérmelo saber en la sección de comentarios a continuación.