El test falló: cómo mostrar el diff exacto de objetos complejos en Go con go-cmpArtículo · digest del 26 de octubre
Interfaz de terminal depurando tests en Go con el resaltado diferencial de google/go-cmp sobre pantalla grafito.
Artículo3 secciones≈ 5 min

El test falló: cómo mostrar el diff exacto de objetos complejos en Go con go-cmp

Imagina una escena cotidiana: ejecutas los tests en un proyecto de Go y uno de ellos falla con un mensaje lacónico: expected true, got false. Abres el archivo de pruebas y te encuentras la clásica llamada reflect.DeepEqual(want, got). A la entrada tienes una estructura anidada de respuesta API con treinta campos, arrays internos, marcas temporales y metadatos. ¿Cuál de todos esos campos no coincidió? Imposible saberlo.

Ahí es cuando el desarrollador empieza a llenar todo de fmt.Printf("%+v\n"), a volcar objetos en JSON formateado y a comparar a ojo dos sábanas interminables de texto. En lugar de tardar un par de segundos en corregir el bug, se te van quince minutos buscando un error tonto en un flag booleano.

En la biblioteca estándar de Go este problema lleva años ahí: reflect.DeepEqual devuelve un sí o un no binario y no sabe mostrar diferencias con contexto. La solución creada por ingenieros de Google es la librería oficial go-cmp (versión actual v0.7.0). Está diseñada específicamente para tests y convierte la depuración en una comparación visual inmediata.

Anatomía de cmp.Diff: cómo leer los marcadores -want y +got

La herramienta principal de la librería es la función cmp.Diff(want, got). Si los objetos son idénticos, devuelve una cadena vacía. Pero si hay aunque sea una mínima discrepancia, genera un informe compacto y legible donde resalta únicamente los campos distintos.

Añadir el paquete al proyecto se hace con el comando habitual:

go get -u github.com/google/go-cmp/cmp@v0.7.0

Al imprimir el informe, la librería utiliza una notación diferencial muy intuitiva:

  • Las líneas con signo menos (-) corresponden al valor esperado (want);
  • Las líneas con signo más (+) muestran lo que devolvió realmente tu código (got).

Mira lo limpio y expresivo que queda el código de pruebas:

package user_test

import (
    "testing"
    "github.com/google/go-cmp/cmp"
    "github.com/google/go-cmp/cmp/cmpopts"
)

type UserProfile struct {
    ID       int64
    Username string
    Roles    []string
    authHash string // campo privado no exportado
}

func TestUserProfile(t *testing.T) {
    want := UserProfile{
        ID:       42,
        Username: "alex",
        Roles:    nil, // slice nil
    }
    got := UserProfile{
        ID:       42,
        Username: "alex",
        Roles:    []string{}, // slice vacío de longitud cero
    }

    // Reglas de comparación: ignoramos campos privados y equiparamos colecciones vacías
    diff := cmp.Diff(want, got,
        cmpopts.IgnoreUnexported(UserProfile{}),
        cmpopts.EquateEmpty(),
    )

    if diff != "" {
        t.Errorf("UserProfile mismatch (-want +got):\n%s", diff)
    }
}

Si quitas esas opciones, el test señalará al instante la discrepancia exacta entre los elementos anidados sin ruido alrededor del resto de campos. Esto encaja perfectamente con la práctica de TDD y tests fiables en Go: una prueba que falla debe decirte de inmediato el motivo exacto del fallo.

La trampa de los slices vacíos y los campos no exportados

Muchos desarrolladores que prueban go-cmp por primera vez tropiezan con dos particularidades clave de la librería:

  1. Diferencia estricta entre nil y colección vacía: en Go, un slice var s []string = nil y un slice inicializado s := []string{} son semánticamente distintos, aunque ambos tengan longitud cero. Por defecto, go-cmp los considera objetos diferentes. Si en tu escenario de negocio eso da igual, añade siempre el transformador cmpopts.EquateEmpty(). Eso sí, ten cuidado: si un serializador JSON debe devolver null y no un array vacío [], igualarlos a ciegas ocultará un bug de contrato.
  2. Pánico en campos no exportados: si una estructura contiene campos privados en minúscula (como authHash), la librería lanza intencionadamente un pánico (panic: cannot handle unexported field) para proteger el encapsulamiento del tipo. Estás obligado a declarar tu intención de forma explícita: o los ignoras con cmpopts.IgnoreUnexported(Type{}), o permites inspeccionarlos con cmp.AllowUnexported(Type{}).

Comparadores personalizados y límites de uso

Otro superpoder de cmp.Diff es la posibilidad de definir reglas de comprobación a medida mediante cmp.Comparer. Un caso clásico es comparar marcas temporales time.Time, donde el reloj monotónico o diferencias de nanosegundos provocan falsos positivos en los tests:

// Comparador que trunca el tiempo a segundos antes de comparar
var timeComparer = cmp.Comparer(func(x, y time.Time) bool {
    return x.Truncate(time.Second).Equal(y.Truncate(time.Second))
})

Eso sí, recuerda para qué fue creado el paquete: go-cmp está pensado exclusivamente para pruebas. Debido a su uso intensivo de reflection, no está optimizado para alto rendimiento y puede volverse lento con arrays de decenas de miles de elementos. No conviene usarlo para comparar objetos en código de producción.

Para tests unitarios y de integración del día a día, go-cmp ahorra muchísimo tiempo y nervios, haciendo que cada fallo se entienda al primer vistazo.

Quiero un análisis detalladoLos votos ayudan a elegir qué analizar a fondo. Este material tiene 0 votos.
Fuentes · 2