Tests unitarios y code coverage en Go

Clase 17 de 30 • Curso de Go Intermedio: Programación Orientada a Objetos y Concurrencia

Resumen

¿Qué es el testing y por qué es importante?

El testing es una parte fundamental en el ciclo de desarrollo de software. Aunque es un tema vasto que podría requerir cursos enteros dedicados, en este contexto nos centraremos en crear pruebas unitarias para el código que desarrollamos. Las pruebas unitarias son pequeñas evaluaciones que verifican el comportamiento de funciones individuales. Este proceso no solo valida que el código funciona como se espera, sino que también nos ayuda a garantizar la calidad y a detectar errores con anticipación. Además, vamos a medir el code coverage, que nos indica qué porcentaje de nuestro código está cubierto por estas pruebas.

¿Cómo creamos pruebas unitarias en Go?

Para ilustrar el proceso de creación de pruebas unitarias en Go, comenzamos creando un archivo principal, main.go, que contiene una función simple de suma. Después, crearemos un archivo de pruebas, main_test.go, donde escribiremos las pruebas para la función de suma. Este archivo de pruebas debe seguir un formato específico para que Go lo reconozca, usando el sufijo _test.go.

Configuración inicial

Primero, definimos el paquete principal y la función que vamos a probar:

package main

func sum(x, y int) int {
    return x + y
}

Creación de la prueba unitaria

En el archivo main_test.go, definimos el paquete y la función de prueba. Es esencial importar el paquete testing, ya que proporciona las herramientas necesarias para verificar los resultados de las pruebas.

package main

import "testing"

func TestSum(t *testing.T) {
    total := sum(5, 5)
    if total != 10 {
        t.Errorf("Suma incorrecta, obtuvimos %d, pero esperábamos %d", total, 10)
    }
}

Ejecutando las pruebas

Para ejecutar las pruebas, utilizamos el comando go test desde la terminal. Si configuramos correctamente nuestro módulo con go mod init, las pruebas deberían ejecutarse sin problemas. En caso de haber errores, Go reportará los fallos y sus ubicaciones específicas en el código.

¿Cómo utilizamos tablas de prueba para múltiples casos?

Un patrón común para aplicar pruebas en Go es el uso de tablas de prueba. Esta técnica nos permite definir múltiples escenarios de prueba en un slice de structs, facilitando la iteración y ejecución de cada caso.

Creación de una tabla de pruebas

Definimos una estructura para nuestros casos de prueba, que incluya los valores de entrada y el resultado esperado.

func TestSum(t *testing.T) {
    testCases := []struct{a, b, expected int}{
        {1, 2, 3},
        {2, 2, 4},
        {25, 26, 51},
    }

    for _, tc := range testCases {
        result := sum(tc.a, tc.b)
        if result != tc.expected {
            t.Errorf("Suma incorrecta, obtuvimos %d, pero esperábamos %d", result, tc.expected)
        }
    }
}

Ventajas de las tablas de pruebas

Este enfoque no solo organiza el proceso de pruebas, sino que también permite agregar y modificar casos fácilmente sin cambiar la lógica de prueba. Además, proporciona un marco claro para identificar fallos específicos cuando ocurren.

¿Qué impacto tiene el code coverage?

El code coverage es una métrica que indica qué parte de nuestro código ha sido ejecutada durante las pruebas. Aunque Go no obliga a cubrir el 100% del código, un bajo porcentaje de cobertura podría ocultar errores en partes no probadas. Go ofrece comandos para generar informes de cobertura, permitiéndonos identificar y mejorar áreas deficientes en nuestras pruebas.

Integración del code coverage

Para calcular el code coverage, podemos usar el comando go test -cover, que mostrará un resumen del porcentaje de código cubierto por las pruebas. Esta práctica nos ayuda a mantener un estándar de calidad alto y a asegurar que todas las partes críticas del código estén debidamente verificadas.

El uso consciente de pruebas unitarias y el seguimiento del code coverage no solo mejoran la calidad del software, sino que también aumentan la confianza en nuestras aplicaciones. Invito a continuar explorando y aplicando estos conceptos en sus proyectos para asegurar un desarrollo más sólido y eficiente.

Àlex Grau Roca

student•

Para programar los tests os recomiendo utilizar el módulo , ya que te ofrece diversas funcionalidades que facilitan la vida a la hora de programar los tests de Go.

Yo encuentro especialmente útil el paquete assert, el qual te permite hacer los asserts igual que en cualquier lenguaje de programación. Por ejempo:

assert.Equal(t, 63997.93, newImport)

William Méndez

student•

Uso esa herramienta para los mocks aparte de los asserts, es un recurso bastante útil.

Alejandro Ibarra Rodriguez

student•

Bastante interesante la forma de manejar los tests con el slice de structs

Sebastian Leonel Godirio

student•

Una forma de darle descripcion a todos los casos de uso de los tests:

func Test_Sum(t *testing.T) {
	tables := []struct {
		description string
		a           int
		b           int
		total       int
	}{
		{
			description: "adding 2 digit numbers",
			a:           12,
			b:           20,
			total:       32,
		},
		{
			description: "adding 1 digit numbers",
			a:           2,
			b:           2,
			total:       4,
		},
	}

	for _, item := range tables {
		t.Run(item.description, func(t *testing.T) {
			if totalSum := Sum(item.a, item.b); totalSum != item.total {
				t.Errorf("error: incorrect sum. got %d, expected %d", totalSum, item.total)
			}
		})
	}
}

En este caso solo hay un caso de uso, pero hay veces que vamos a tener muchisimos casos de uso, como por ejemplo, una funcion puede retornar distintos tipos de errores, y lo ideal es cubrir cada uno de ellos. Por esto, tener una descripcion por caso de uso no ayuda mucho a mantener los tests limpios y entendibles

Johan Vargas

student•

Como buena practica el paquete de los test deberia llamrse "main_test" y no directamente como el paquete, esto para temas de seguridad y que go no compile nuestros test dentro de build

Christian Molina Vázquez

student•

Para correr los test en paralelo.

package main

import "testing"

// func TestSum(t *testing.T) {
// 	total := Sum(5, 5)
// 	if total != 10 {
// 		t.Error("Suma was incorrect, got ", total, "expected ", 10)
// 	}
// }

func TestSum(t *testing.T) {
	t.Parallel()
	testCases := []struct {
		desc    string
		a, b, n int
	}{
		{
			desc: "Tetsing 1+2 = 3",
			a:    1, b: 2, n: 3,
		},
		{
			desc: "Tetsing 2+2 = 4",
			a:    2, b: 2, n: 4,
		},
		{
			desc: "Tetsing 25+26 = 51",
			a:    25, b: 26, n: 51,
		},
	}
	for _, tC := range testCases {
		tC := tC
		t.Run(tC.desc, func(t *testing.T) {
			t.Parallel()
			total := Sum(tC.a, tC.b)
			if total != tC.n {
				t.Error("Sum was incorrect, got", total, "expected", tC.n)
			}
		})
	}
}

Sebastian CA

student•

Testing

Go has a builtin testing library, which is awesome!

How To:

To define a test must:
1. Create a the test file named <file>_test.go, where <file> is the name of the file you are testing
2. Write the tests
3. Run the tests with go test
Example:

main.go:
```
package main

func Sum(x, y int) int {
	return x + y
}
```

main_test.go:

package main

import (
	"fmt"
	"testing"
)

func TestSum(t *testing.T) {
	fmt.Println()
	total := Sum(5, 5)

	if total != 10 {
		t.Errorf("Wrong output, expected 10, go %d", total)
	}
}

Often times it's useful to test various cases in single test. To do that you'd wanna use a slice and iterate over them like so:

tableCases := []struct {
	a int
	b int
	n int
}{
	{1, 2, 3},
	{2, 2, 4},
	{25, 26, 51},
}

for _, item := range tableCases {
	total := Sum(item.a, item.b)
	if total != item.n {
		t.Errorf("Failed: Incorrect sum, got %d expected %d", total, item.n)
	}
}

Leander Perez

student•

main.go

package main

import (
	"fmt"
	"strings"
)

func Sum(x, y int) int {
	return x + y
}

func SayHello(name string) string {
	return fmt.Sprintf("Hello %v", strings.Title(strings.ToLower(name)))
}

func GreaterThan(x, y int) int {
	if x > y {
		return x
	}
	return y
}

func SumTotal(numbers ...int) int {
	total := 0
	for _, val := range numbers {
		total += val
	}
	return total
}

main_test.go

package main

import (
	"testing"
)

func TestSum(t *testing.T) {
	type args struct {
		x int
		y int
	}
	tests := []struct {
		name string
		args args
		want int
	}{
		// TODO: Add test cases.
		{name: "Test Sum Correct", args: args{x: 6, y: 6}, want: 12},
		{name: "Test Sum Correct", args: args{x: 5, y: 5}, want: 10},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := Sum(tt.args.x, tt.args.y); got != tt.want {
				t.Errorf("Sum() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestSayHello(t *testing.T) {
	type args struct {
		name string
	}
	tests := []struct {
		name string
		args args
		want string
	}{
		// TODO: Add test cases.
		{name: "Correctly", args: args{name: "pedro"}, want: "Hello Pedro"},
		{name: "Correctly", args: args{name: "Ramon"}, want: "Hello Ramon"},
		{name: "Correctly", args: args{name: "mARIa"}, want: "Hello Maria"},
		{name: "Correctly", args: args{name: "DIANA"}, want: "Hello Diana"},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := SayHello(tt.args.name); got != tt.want {
				t.Errorf("SayHello() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestGreaterThan(t *testing.T) {
	type args struct {
		x int
		y int
	}
	tests := []struct {
		name string
		args args
		want int
	}{
		// TODO: Add test cases.
		{name: "Equal", args: args{x: 6, y: 6}, want: 6},
		{name: "X greater", args: args{x: 9, y: 8}, want: 9},
		{name: "Y greater", args: args{x: 1, y: 99}, want: 99},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := GreaterThan(tt.args.x, tt.args.y); got != tt.want {
				t.Errorf("GreaterThan() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestSumTotal(t *testing.T) {
	type args struct {
		numbers []int
	}
	tests := []struct {
		name string
		args args
		want int
	}{
		// TODO: Add test cases.
		{name: "Correctly", args: args{[]int{1, 3, 2}}, want: 6},
		{name: "Correctly", args: args{[]int{106, 105, 6}}, want: 217},
		{name: "Correctly", args: args{[]int{96, 3, 0}}, want: 99},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := SumTotal(tt.args.numbers...); got != tt.want {
				t.Errorf("SumTotal() = %v, want %v", got, tt.want)
			}
		})
	}
}

Carlos Nassif Trejo Garcia

student•

main_test

package main

import "testing"

func TestSum(t *testing.T) {
	tables := []struct {
		x int
		y int
		r int
	}{
		{1, 2, 3},
		{2, 2, 4},
		{3, 2, 5},
		{25, 26, 51},
	}

	for _, table := range tables {
		total := Sum(table.x, table.y)
		if total != table.r {
			t.Errorf("Sum(%d, %d) was incorrect, got: %d, want: %d.", table.x, table.y, total, table.r)
		}
	}
}

main

package main

func Sum(x, y int) int {
	return x + y
}

func GetMax(x, y int) int {
	if x > y {
		return x
	}
	return y
}

Miguel Angel Reyes Moreno

student•

El test para la función GetMax:

func TestGetMax(t *testing.T) {

tables := []struct {

a int

b int

n int

}{

{1,1,1},

{2,2,2},

{3,3,3},

{25,26,26},

{1,0,1},

{0,0,0},

{0,1,1},

{0,-1,0},

}

for _, item := range tables {

max := GetMax(item.a, item.b)

if max != item.n {

t.Errorf("Expected max of %d and %d to be %d, got %d", item.a, item.b, item.n, max)

}

Carlos Ayala

student•

Seria buana practica tener un paquete de testing por fuera de los paquetes de la logica?

Cristian Rodriguez Morales

student•

Cuando ejecuto el comando go test -cover obtengo de regreso un coverage: ¨no statements ¿Me ayudas a entender porqué sucede?

Arturo Chiarella

student•

Pense que harian casos de pruebas un poco mas reales, estos test estan en google... ¿entonces platzi?

Jainelker Jesus Yepez

student•

Hola 👋 Muchas gracias por tu observación, definitivamente nos llevaremos tu comentario a la escuela para que puedan desarrollar en las próximas entregas, casos reales para que puedan realizar las pruebas que necesiten.

Wilmer Jose Perez Diaz

student•

Para el testing, siempre me gusta ser muy ordenado y estructurar mi función en tres bloques: Given, When, Then.

package main

import "testing"

func TestSuma(t *testing.T) { // Given tables := []struct { description string a int b int total int }{ {"Suma de 4 + 5", 4, 5, 9}, {"Suma de 5 + 6", 5, 6, 11}, {"Suma de 6 + 7", 6, 7, 13}, {"Suma de 7 + 8", 7, 8, 15}, }

for _, table := range tables { t.Run(table.description, func(t *testing.T) { // When total := Suma(table.a, table.b)

// Then if total != table.total { t.Errorf("Suma de %d + %d incorrecta, se obtuvo: %d, se esperaba: %d", table.a, table.b, total, table.total) } }) } }

Wilmer Jose Perez Diaz

student•

package main

import "testing"

func TestSuma(t *testing.T) {
	// Given
	tables := []struct {
		description string
		a           int
		b           int
		total       int
	}{
		{"Suma de 4 + 5", 4, 5, 9},
		{"Suma de 5 + 6", 5, 6, 11},
		{"Suma de 6 + 7", 6, 7, 13},
		{"Suma de 7 + 8", 7, 8, 15},
	}

	for _, table := range tables {
		t.Run(table.description, func(t *testing.T) {
			// When
			total := Suma(table.a, table.b)

			// Then
			if total != table.total {
				t.Errorf("Suma de %d + %d incorrecta, se obtuvo: %d, se esperaba: %d", table.a, table.b, total, table.total)
			}
		})
	}
}

Samuel Soto Hoyos

student•

200 de IQ usar los slices de structs para hacer las pruebas.

LEONARD CUENCA

student•

Clases 17: Testing

Como generar un testing en GO

Paso 1: debemos crear un archivo go con el sufijo test Ejemplo -> main_test.go
Paso 2: tener definido que vamos a evaluar para este ejemplo usaremos este archivo ->
Paso 3: iniciamos a escribir nuestras pruebas ejemplo de codificación -> pruebas
Paso 4: para generar testing debemos crear un mod para poder crearlo ejecutamos este comando go mod init nombreModulo
Paso 5: usamos el comando go test y este nos indicará si la prueba corrió bien

Me apoyan a validar si me equivoque gente.

Johan Avila

student•

Test tables example https://dave.cheney.net/2013/06/09/writing-table-driven-tests-in-go

Juan Londono Esteban Londoño

student•

El curso la verdad es excelente, super bien explicado y las testing y es la parte fundamental de un codigo de alta calidad

Oscar Jaramillo

student•

Interesante

Tests unitarios y code coverage en Go

Introducción

Programación Orientada a Objetos y Concurrencia en Go

Concurrencia y Testing en Go: Go Routinas y Worker Pools

Fundamentos de Programación en Go: Structs, Apuntadores y Manejo de Errores

Go Routines, Canales y Apuntadores en Golang

Programación orientada a objetos

Programación Orientada a Objetos en Go: Análisis y Comparativa

Equivalente de Clases en Go: Uso de Structs y Propiedades

Métodos en Structs: Implementación de Receiver Functions en Go

Implementación de Constructores en Go: Ejemplos y Mejores Prácticas

Herencia y Composición en Programación Orientada a Objetos

Interfaces y Polimorfismo en TypeScript y Go

Patrón Abstract Factory: Interfaces y Polimorfismo en Go

Implementación del Patrón Factory en Go para Notificaciones

Funciones Anónimas en Go: Uso y Consideraciones Prácticas

Funciones Variádicas y Retornos con Nombre en Go

Go Modules

Manejo de Dependencias y Módulos en Go

Creación y Publicación de Módulos en GitHub con Go

Testing