gomock para Go: guía completa para simular interfaces

1. ¿Qué es y para qué sirve?

En el desarrollo moderno con Go, las pruebas son fundamentales. Sin embargo, a menudo el código depende de sistemas externos: bases de datos, clientes HTTP, sistemas de archivos u otros microservicios. Probar este código de forma aislada es complicado, ya que estas dependencias requieren un entorno real. Aquí es donde entra gomock, una potente librería para generar y usar mocks (simulaciones) de interfaces en Go.

gomock te permite crear automáticamente implementaciones de interfaces que se comportan de forma predecible: devuelven valores específicos, verifican el orden de las llamadas, cuentan el número de invocaciones e incluso simulan errores. Esto hace que las pruebas unitarias sean rápidas, deterministas e independientes de recursos externos. La librería se integra estrechamente con el paquete estándar testing y es el estándar de facto para simulación en la comunidad Go.

El valor principal de gomock es que pruebas el comportamiento de tu código, no su implementación. Verificas que tu servicio llame correctamente a los métodos de las dependencias con los argumentos adecuados y que procese los resultados de forma correcta. Esto es especialmente importante al seguir los principios SOLID y el patrón de Inyección de Dependencias (Dependency Injection).

2. Instalación

Para trabajar con gomock necesitas instalar dos componentes:

1. La librería gomock — contiene el runtime para trabajar con mocks.
2. La utilidad mockgen — generador de código de mocks a partir de interfaces.

La instalación se realiza a través del gestor de paquetes estándar de Go:

# Instalar la librería
go get github.com/golang/mock/gomock

# Instalar la utilidad mockgen
go install github.com/golang/mock/mockgen@v1.6.0

Después de la instalación, asegúrate de que mockgen esté disponible en tu PATH. Puedes verificarlo con el comando:

mockgen --version

Si usas Go 1.16+, se recomienda agregar mockgen en tools.go para mantener el versionado:

// tools.go
// +build tools

package tools

import (
    _ "github.com/golang/mock/mockgen"
)

3. Inicio rápido — ejemplo mínimo funcional

Veamos un ejemplo sencillo. Supongamos que tenemos una interfaz Greeter que queremos simular.

// greeter.go
package main

// Greeter — interfaz que vamos a simular
type Greeter interface {
    Greet(name string) string
}

// Service usa Greeter
type Service struct {
    greeter Greeter
}

func NewService(g Greeter) *Service {
    return &Service{greeter: g}
}

func (s *Service) SayHello(name string) string {
    return s.greeter.Greet(name)
}

Primero, generamos el mock:

mockgen -source=greeter.go -destination=mock_greeter.go -package=main

Ahora escribimos la prueba:

// greeter_test.go
package main

import (
    "testing"
    "github.com/golang/mock/gomock"
)

func TestSayHello(t *testing.T) {
    // Creamos el controlador de gomock
    ctrl := gomock.NewController(t)
    defer ctrl.Finish()

    // Creamos el mock de Greeter
    mockGreeter := NewMockGreeter(ctrl)

    // Configuramos la expectativa: al llamar Greet("Alice") devolver "Hello, Alice!"
    mockGreeter.EXPECT().Greet("Alice").Return("Hello, Alice!")

    // Creamos el servicio con el mock
    service := NewService(mockGreeter)

    // Llamamos al método bajo prueba
    result := service.SayHello("Alice")

    // Verificamos el resultado
    if result != "Hello, Alice!" {
        t.Errorf("Se esperaba 'Hello, Alice!', pero se obtuvo '%s'", result)
    }
}

Ejecuta la prueba:

go test -v

Verás que la prueba se ejecuta correctamente. El mock verificó automáticamente que