Mis apuntes · Aprende Go desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 24 de 36 · Un proyecto real ✦ WebMCP implementado

Tests en Go: de PHPUnit a go test

9 min de lectura 3 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/.

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:

  1. 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.
  2. Su nombre empieza por Test seguido de mayúscula: TestContarHechas.
  3. Recibe un único parámetro t *testing.T: el objeto con el que avisas de los fallos (el $this de tu TestCase).
PHP 8.5contar_hechas_test.php
<?php
declare(strict_types=1);

namespace App\Tests\Tareas;

use App\Tareas\Tarea;
use PHPUnit\Framework\TestCase;

use function App\Tareas\contarHechas;

final class ContarHechasTest extends TestCase
{
    public function testCuentaSoloLasHechas(): void
    {
        $tareas = [
            new Tarea(1, "Comprar pan", hecha: true),
            new Tarea(2, "Llamar al banco"),
            new Tarea(3, "Repasar Go", hecha: true),
        ];

        $this->assertSame(2, contarHechas($tareas));
    }
}
Gotareas_test.go
// Mismo paquete que el código: ve también lo privado.
package tareas

import "testing"

func TestContarHechas(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.

PHPUnitGoQué cambia
class TareaTest extends TestCaseFichero tarea_test.goNo hay clase ni herencia: el fichero agrupa los tests
public function testAlgo(): voidfunc 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.RunDatos y bucle en el mismo sitio
Probar un método privateSe puede: el test está en el mismo paqueteSin 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:

LlamadaQué haceCuándo usarla
t.Errorf(...)Marca el test como fallido y sigueCasi siempre: así ves todos los fallos de una vez
t.Fatalf(...)Marca el fallo y para el testCuando seguir no tiene sentido (un error al abrir, un nil)
t.Helper()En los fallos, señala la línea de quien llamaDentro de tus funciones de ayuda
t.Cleanup(f)Ejecuta f al terminar el testTu 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"
)

var ErrTareaNoEncontrada = errors.New("tarea no encontrada")

var tareas = map[int]string{1: "Comprar pan", 2: "Repasar Go"}

func BuscarTitulo(id int) (string, error) {
    titulo, ok := tareas[id]
    if !ok {
        return "", ErrTareaNoEncontrada
    }
    return titulo, nil
}

func TestBuscarTituloExiste(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")
    }
}

func TestBuscarTituloNoExiste(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.
func main() {
    testing.Init()
    flag.Set("test.v", "true")
    testing.Main(
        func(patron, nombre string) (bool, error) { return true, 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.
func NormalizaTitulo(s string) string {
    s = strings.TrimSpace(s)
    if s == "" {
        return ""
    }
    letras := []rune(s)
    letras[0] = unicode.ToUpper(letras[0])
    return string(letras)
}

func TestNormalizaTitulo(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.
func main() {
    testing.Init()
    flag.Set("test.v", "true")
    testing.Main(
        func(patron, nombre string) (bool, error) { return true, 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
func BenchmarkNormalizaTitulo(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

OrdenQué haceEn PHPUnit
go test ./...Todos los tests del módulovendor/bin/phpunit
go test -v ./tareasCuenta 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 guardadosNo existe: PHPUnit no guarda resultados
go test -bench=. ./...Ejecuta los benchmarksPHPBench

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
func ExampleNormalizaTitulo() {
    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

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

Resumen

Lo que te llevas de esta lección

  1. Fichero *_test.go, función TestAlgo(t *testing.T) y go test ./... (en PHP, AlgoTest extends TestCase y phpunit).
  2. Sin asserts: un if y t.Errorf("obtenido %v, quiero %v") (en PHP, assertSame()).
  3. t.Errorf sigue y t.Fatalf para (en PHPUnit, el assert siempre para).
  4. Tests de tabla con t.Run (en PHP, #[DataProvider]).
  5. -v, -run, -cover y -bench vienen incluidos (en PHP, PHPUnit + Xdebug + PHPBench).
  6. 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».