Lección 24 de 36 · Un proyecto real✦ WebMCP implementado
Tests en Go: de PHPUnit a go test
9 min de lectura3 retos
En PHP instalas PHPUnit con Composer, heredas de TestCase y llamas a assertSame(). En Go los tests vienen de serie: un fichero que acaba en _test.go, funciones que empiezan por Test y la orden go test. Sin librerías, sin clases y sin asserts.
¿De dónde vienen los nombres?
Errorf = Error + f (formatted, con formato)
Apunta un fallo con un mensaje al estilo printf() y deja que el test siga. Como un assert que no se para.
Fatalf = Fatal + f (formatted)
Apunta el fallo y para ese test en seco, porque seguir no tiene sentido. Como un assert de PHPUnit, que corta el método.
-v = verbose (detallado)
Hace que go test cuente cada test que ejecuta, no solo los que fallan. El --testdox de PHPUnit, más o menos.
-cover = coverage (cobertura)
Dice qué porcentaje de tu código han pisado los tests. El --coverage-text de PHPUnit, sin instalar Xdebug ni PCOV.
En 4 ideas
1/4
Los tests van en ficheros *_test.go junto al código, en el mismo paquete, y cada test es una función func TestAlgo(t *testing.T). En PHP: una clase AlgoTest extends TestCase en la carpeta tests/.
No hay assertSame(): comparas con un if y, si no cuadra, llamas a t.Errorf("obtenido %v, quiero %v", ...). En PHP sería escribir tú el if y el mensaje del assert.
Los tests de tabla son un slice de casos que recorres con t.Run(nombre, ...). Es el #[DataProvider] de PHPUnit, pero con código normal y sin atributos.
go test lo trae Go: -v para verlo todo, -run para filtrar, -cover para la cobertura y -bench para medir velocidad. En PHP harían falta PHPUnit, Xdebug y PHPBench.
1 · Tu primer test
Un test en Go es una función normal con tres reglas. Si las cumples, go test la encuentra sola, igual que PHPUnit encuentra los métodos que empiezan por test:
Vive en un fichero que acaba en _test.go, por ejemplo tareas_test.go. go build ignora esos ficheros: los tests nunca acaban en tu binario.
Su nombre empieza por Test seguido de mayúscula: TestContarHechas.
Recibe un único parámetrot *testing.T: el objeto con el que avisas de los fallos (el $this de tu TestCase).
// Mismo paquete que el código: ve también lo privado.package tareas
import"testing"funcTestContarHechas(t *testing.T) {
ts := []Tarea{
{ID: 1, Titulo: "Comprar pan", Hecha: true},
{ID: 2, Titulo: "Llamar al banco"},
{ID: 3, Titulo: "Repasar Go", Hecha: true},
}
obtenido := ContarHechas(ts)
// En PHP: $this->assertSame(2, contarHechas($tareas));if obtenido != 2 {
t.Errorf("ContarHechas() = %d, quiero %d", obtenido, 2)
}
}
Se ejecuta desde la raíz del módulo. ./... significa «este paquete y todos los de debajo», como phpunit sin argumentos. Si todo va bien, una línea por paquete. Si ContarHechas tuviera un fallo y contara las pendientes, verías el fichero, la línea y tu mensaje:
$ go test ./...
? github.com/tuusuario/tareas/cmd/tareas [no test files]
ok github.com/tuusuario/tareas/tareas 0.021s
$ go test ./tareas
--- FAIL: TestContarHechas (0.00s)
tareas_test.go:16: ContarHechas() = 1, quiero 2
FAIL
FAIL github.com/tuusuario/tareas/tareas 0.021s
FAIL
Equivalencia POO · PHP → Go
Todo lo que en PHPUnit es una clase con herencia, en Go es una función suelta y un parámetro t.
PHPUnit
Go
Qué cambia
class TareaTest extends TestCase
Fichero tarea_test.go
No hay clase ni herencia: el fichero agrupa los tests
public function testAlgo(): void
func TestAlgo(t *testing.T)
El prefijo Test hace lo que hacía test
$this->assertSame($a, $b)
if a != b { t.Errorf(...) }
El if lo escribes tú; el mensaje también
setUp() / tearDown()
Código al principio del test / t.Cleanup(func() {...})
Sin métodos mágicos: lo ves todo en el test
#[DataProvider('casos')]
Slice de casos + t.Run
Datos y bucle en el mismo sitio
Probar un método private
Se puede: el test está en el mismo paquete
Sin ReflectionMethod::setAccessible()
2 · t.Errorf y t.Fatalf: sin asserts
Go no trae assertSame() ni assertTrue(). Comparas con un if, como en cualquier otro código, y si algo no cuadra se lo dices a t:
Llamada
Qué hace
Cuándo usarla
t.Errorf(...)
Marca el test como fallido y sigue
Casi siempre: así ves todos los fallos de una vez
t.Fatalf(...)
Marca el fallo y para el test
Cuando seguir no tiene sentido (un error al abrir, un nil)
t.Helper()
En los fallos, señala la línea de quien llama
Dentro de tus funciones de ayuda
t.Cleanup(f)
Ejecuta f al terminar el test
Tu tearDown(): borrar ficheros, cerrar cosas
El mensaje sigue siempre la misma receta: qué llamaste, qué obtuviste y qué querías. Con ContarHechas() = 1, quiero 2 entiendes el fallo sin abrir el test.
En el navegador no hay go test, pero podemos llamar a la misma maquinaria que usa por dentro (testing.Main). Pulsa Ejecutar: son dos tests de verdad, uno con Fatalf y otro con Errorf.
Gomain.go
package main
import (
"errors""flag""testing"
)
varErrTareaNoEncontrada = errors.New("tarea no encontrada")
var tareas = map[int]string{1: "Comprar pan", 2: "Repasar Go"}
funcBuscarTitulo(id int) (string, error) {
titulo, ok := tareas[id]
if !ok {
return"", ErrTareaNoEncontrada
}
return titulo, nil
}
funcTestBuscarTituloExiste(t *testing.T) {
titulo, err := BuscarTitulo(1)
// Si hay error, comparar el título no tiene sentido: paramos.if err != nil {
t.Fatalf("BuscarTitulo(1) dio error: %v", err)
}
// En PHP: $this->assertSame("Comprar pan", $titulo);if titulo != "Comprar pan" {
t.Errorf("BuscarTitulo(1) = %q, quiero %q", titulo, "Comprar pan")
}
}
funcTestBuscarTituloNoExiste(t *testing.T) {
_, err := BuscarTitulo(99)
// En PHP: $this->expectException(TareaNoEncontrada::class);if !errors.Is(err, ErrTareaNoEncontrada) {
t.Errorf("BuscarTitulo(99) error = %v, quiero %v", err, ErrTareaNoEncontrada)
}
}
// Solo para el navegador: así lanza go test -v tus tests.funcmain() {
testing.Init()
flag.Set("test.v", "true")
testing.Main(
func(patron, nombre string) (bool, error) { returntrue, nil },
[]testing.InternalTest{
{Name: "TestBuscarTituloExiste", F: TestBuscarTituloExiste},
{Name: "TestBuscarTituloNoExiste", F: TestBuscarTituloNoExiste},
},
nil, nil,
)
}
¿Por qué? · En PHP no existe
¿Por qué Go no trae asserts? En PHP no te lo plantearías
Con PHPUnit aprendes dos idiomas: PHP para tu código y otro para los tests (assertSame, assertCount, assertInstanceOf, expectException…). Y un assert mal elegido da mensajes confusos, como Failed asserting that false is true.
El equipo de Go decidió que un test es código normal. Ventajas:
No hay nada que aprender: if, == y errors.Is ya los sabes.
Tú escribes el mensaje, así que dice exactamente qué falló y con qué datos.
Eliges si el fallo para el test (Fatalf) o si sigue (Errorf), en vez de que el assert lo decida por ti.
Si echas de menos los asserts existe la librería testify, muy usada. Pero empieza sin ella: la mayoría del código Go, incluida la biblioteca estándar, no la usa.
3 · Tests de tabla y t.Run
Lo más típico en Go: en vez de copiar el test cinco veces, haces una tabla de casos (un slice de structs) y la recorres. Cada caso lleva un nombre y t.Run lo convierte en un subtest con ese nombre. Es tu #[DataProvider], pero sin atributos: los datos están justo encima del bucle.
Gomain.go
package main
import (
"flag""strings""testing""unicode"
)
// NormalizaTitulo quita espacios y pone la primera letra en mayúscula.funcNormalizaTitulo(s string) string {
s = strings.TrimSpace(s)
if s == "" {
return""
}
letras := []rune(s)
letras[0] = unicode.ToUpper(letras[0])
returnstring(letras)
}
funcTestNormalizaTitulo(t *testing.T) {
// En PHP: public static function casos(): array { return [...]; }
casos := []struct {
nombre string
entrada string
quiero string
}{
{"ya bien", "Comprar pan", "Comprar pan"},
{"espacios", " comprar pan ", "Comprar pan"},
{"tilde", "árbol de tareas", "Árbol de tareas"},
{"vacío", "", ""},
}
for _, c := range casos {
t.Run(c.nombre, func(t *testing.T) {
obtenido := NormalizaTitulo(c.entrada)
if obtenido != c.quiero {
t.Errorf("NormalizaTitulo(%q) = %q, quiero %q", c.entrada, obtenido, c.quiero)
}
})
}
}
// Solo para el navegador: así lanza go test -v tus tests.funcmain() {
testing.Init()
flag.Set("test.v", "true")
testing.Main(
func(patron, nombre string) (bool, error) { returntrue, nil },
[]testing.InternalTest{{Name: "TestNormalizaTitulo", F: TestNormalizaTitulo}},
nil, nil,
)
}
Como cada caso tiene nombre, puedes ejecutar solo uno con -run. Los espacios del nombre se convierten en _:
$ go test -v -run 'TestNormalizaTitulo/espacios' ./tareas
=== RUN TestNormalizaTitulo
=== RUN TestNormalizaTitulo/espacios
--- PASS: TestNormalizaTitulo (0.00s)
--- PASS: TestNormalizaTitulo/espacios (0.00s)
PASS
ok github.com/tuusuario/tareas/tareas 0.054s
¿Por qué? · En PHP no existe
¿Por qué una tabla y no un #[DataProvider]?
En PHPUnit, los datos viven en otro método y se enganchan con un atributo (o una anotación @dataProvider en versiones antiguas). Si escribes mal el nombre del método, el test no se ejecuta o falla de forma rara, y para leer un caso saltas de un sitio a otro.
En Go la tabla es un slice normal dentro del test: el compilador comprueba los tipos de cada caso, lo lees todo de arriba abajo y añadir un caso es añadir una línea.
4 · Benchmarks: ¿cuánto tarda?
Un benchmark mide cuánto tarda una función. En PHP usarías PHPBench o un microtime() a mano. En Go es otra función en el _test.go, que empieza por Benchmark y recibe b *testing.B:
Gomain.go
funcBenchmarkNormalizaTitulo(b *testing.B) {
// b.Loop() repite el cuerpo hasta tener una medida fiable.for b.Loop() {
NormalizaTitulo(" comprar pan ")
}
}
$ go test -bench=. -run='^$' ./tareas
goos: linux
goarch: arm64
pkg: github.com/tuusuario/tareas/tareas
BenchmarkNormalizaTitulo-2 2611422 452.1 ns/op
PASS
ok github.com/tuusuario/tareas/tareas 1.208s
Se lee así: la función se ejecutó 2.611.422 veces y cada una tardó unos 452 nanosegundos (ns/op, nanosegundos por operación). El -2 es el número de CPU que usó. -run='^$' le dice que no ejecute ningún test normal, solo los benchmarks.
5 · go test a fondo: cobertura, filtros y ejemplos
Orden
Qué hace
En PHPUnit
go test ./...
Todos los tests del módulo
vendor/bin/phpunit
go test -v ./tareas
Cuenta cada test, pase o falle
--testdox
go test -run Buscar ./...
Solo los tests cuyo nombre encaja
--filter Buscar
go test -cover ./...
Porcentaje de código cubierto
--coverage-text (con Xdebug o PCOV)
go test -count=1 ./...
Ejecuta sin usar resultados guardados
No existe: PHPUnit no guarda resultados
go test -bench=. ./...
Ejecuta los benchmarks
PHPBench
Hay un tercer tipo de función en los _test.go: los ejemplos. Empiezan por Example, imprimen algo y llevan un comentario // Output: con lo que debe salir. go test comprueba que sale eso, y la web de documentación (pkg.go.dev) los muestra como ejemplos de uso:
Gomain.go
funcExampleNormalizaTitulo() {
fmt.Println(NormalizaTitulo(" comprar pan "))
// Output: Comprar pan
}
Es documentación que no se puede quedar vieja: si cambias la función y el ejemplo deja de cuadrar, el test falla. En PHP, el ejemplo de un comentario PHPDoc nadie lo comprueba.
Hora de practicar
Retos · 0/3 resueltos
Reto 1 de 3 · ✓ Resuelto
Lee el fallo y arregla la función
Al ejecutar go test sale esto: tareas_test.go:16: ContarHechas() = 1, quiero 2. Arregla ContarHechas(ts []Tarea) int para que cuente las tareas hechas. Es un count(array_filter($tareas, fn (Tarea $t) => $t->hecha)) de PHP.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. El mensaje dice que obtienes 1 y quieres 2: estás contando justo las otras. Mira la condición del if.
Reto 2 de 3 · ✓ Resuelto
Escribe la tabla de casos
NormalizaTitulo ya funciona; lo que falta es su tabla de tests. Completa CasosNormaliza() []Caso con al menos 4 casos correctos y con nombres distintos, y que haya uno con la entrada vacía (""), uno con espacios a los lados y uno en el que la función ponga la mayúscula. Los tests ocultos comprueban tu tabla contra la función. Es el método que devuelve tu #[DataProvider] en PHPUnit.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Añade líneas al slice, una por caso. Piensa en lo que hace la función: quita espacios (" Comprar pan "), pone la mayúscula ("repasar Go") y deja vacío lo vacío (""). Pulsa Ejecutar para ver tu tabla como la vería t.Run.
Reto 3 de 3 · ✓ Resuelto
Haz pasar la tabla de prioridades
El _test.go tiene esta tabla: "alta" da Alta; " Media " da Media; "BAJA" da Baja; "urgente" y "" dan un error que envuelve ErrPrioridadInvalida. Completa ParsePrioridad(s string) (Prioridad, error) para que la tabla pase: sin importar mayúsculas ni espacios. Es el Prioridad::tryFrom() de un enum de PHP, más un trim() y un strtolower().
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Normaliza antes del switch con strings.ToLower(strings.TrimSpace(s)), añade el caso "baja" y, al final, devuelve el error envuelto con fmt.Errorf("%w: %q", ErrPrioridadInvalida, s).
Resumen
Lo que te llevas de esta lección
Fichero *_test.go, función TestAlgo(t *testing.T) y go test ./... (en PHP, AlgoTest extends TestCase y phpunit).
Sin asserts: un if y t.Errorf("obtenido %v, quiero %v") (en PHP, assertSame()).
t.Errorf sigue y t.Fatalf para (en PHPUnit, el assert siempre para).
Tests de tabla con t.Run (en PHP, #[DataProvider]).
-v, -run, -cover y -bench vienen incluidos (en PHP, PHPUnit + Xdebug + PHPBench).
Los Example con // Output: son documentación que se comprueba sola.
Para recordarlo: «Obtenido, quiero»
Todo mensaje de fallo dice qué llamaste, qué obtuviste y qué querías: ContarHechas() = 1, quiero 2. Y para la diferencia: «Errorf apunta y sigue; Fatalf apunta y frena».