Todo desarrollador de Go que construye un backend con una base de datos relacional tarde o temprano se enfrenta a la clásica encrucijada de ingeniería: ¿cómo probar la capa de acceso a datos (Repository / DAO) de forma rápida, fiable y sin dolores de cabeza?
El primer camino es usar mocks de SQL como la popular librería go-sqlmock. Las pruebas vuelan en microsegundos directamente en memoria RAM, pero esa comodidad tiene un lado oscuro. Los mocks solo comprueban que tu código llamó a una función con determinada cadena de consulta. No conocen el dialecto de un SGBD concreto, son ciegos a las sutilezas de conversión de tipos, no validan claves foráneas (foreign keys), triggers, índices únicos compuestos ni el comportamiento de expresiones CTE. Al final los tests están en verde, pero en producción el servicio cae con un error de sintaxis SQL ante la primera carga real.
El segundo camino son las pruebas de integración sobre una base de datos real (PostgreSQL, MySQL o SQLite ejecutándose localmente en Docker o mediante Testcontainers). Aquí la verificación es cien por ciento honesta, pero surge el molesto problema del aislamiento de las pruebas. Para que un test no afecte a los resultados de otro, hay que limpiar los datos entre ejecuciones. Pero llamar a TRUNCATE sobre decenas de tablas relacionadas o recrear el esquema mediante migraciones convierte la suite de pruebas en un monstruo torpe: en lugar de segundos, las pruebas tardan minutos, quitando a los ingenieros cualquier gana de ejecutar la verificación antes de hacer commit.
El equipo de DATA-DOG propuso una solución fundamentalmente distinta y técnicamente elegante a este dilema al crear el paquete go-txdb. Es un driver monotransaccional de base de datos que convierte las pruebas sobre un SGBD real en un proceso rápido y totalmente aislado.
Cómo funciona txdb: la magia de interceptar a nivel de database/sql
El secreto de la eficacia de go-txdb reside en la arquitectura del paquete estándar database/sql/driver en Go. En lugar de escribir complejos servidores proxy o parchear bytecode, la librería implementa las interfaces oficiales del driver de Go (driver.Driver, driver.Conn, driver.Tx), actuando como un envoltorio transparente sobre tu driver de producción — por ejemplo, pgx, lib/pq, go-sql-driver/mysql o modernc.org/sqlite.
Cuando tu escenario de prueba solicita una conexión a la base, txdb intercepta el control y ejecuta la siguiente secuencia de acciones:
- Abre una conexión física real al SGBD mediante el driver base indicado;
- Ejecuta de inmediato el comando
BEGIN, pasando la sesión al modo de transacción activa; - Todas las operaciones posteriores de lógica de negocio —
Exec,Query, preparación de sentenciasPrepare— se ejecutan estrictamente dentro de esa única transacción; - La capa de servicio trabaja con la interfaz estándar
*sql.DB, sin sospechar siquiera que está dentro de un sandbox de pruebas; - Cuando el test termina y la conexión se cierra (
db.Close()), txdb ejecuta el comandoROLLBACK.
La base de datos revierte al instante absolutamente todas las filas creadas, modificadas o eliminadas hasta el estado previo al inicio de la prueba. El procedimiento de rollback en el motor PostgreSQL toma fracciones de milisegundo, sin requerir limpieza en disco ni reinicio de catálogos del sistema.
Emulación de transacciones anidadas mediante Savepoints
Seguro que ahora mismo objetas con escepticismo: «¡Pero en el código real de los servicios nosotros mismos abrimos transacciones todo el tiempo con db.Begin() y llamamos a tx.Commit(). Si el código dentro del test confirma la transacción, los datos se guardarán en disco y romperán todo el aislamiento!»
Y es una pregunta totalmente justa, en la que precisamente reside el mayor encanto de la implementación de txdb. Los desarrolladores del driver le enseñaron a virtualizar transacciones anidadas mediante el mecanismo de puntos de guardado (Savepoints), soportado por la mayoría de los SGBD modernos.
Mira lo que ocurre bajo el capó ante las llamadas desde el código de negocio:
- Cuando tu servicio llama a
tx, err := db.Begin(), el driver no envía a la base un segundoBEGIN(lo cual provocaría un error o advertencia), sino que genera un punto de guardado único:SAVEPOINT tx_1; - Si la operación tuvo éxito y el servicio llama a
tx.Commit(), txdb traduce esta acción al comando SQLRELEASE SAVEPOINT tx_1, confirmando el resultado intermedio dentro del contorno general; - Si en cambio ocurrió un fallo en la lógica y el código llamó a
tx.Rollback(), el driver revierte la base exactamente hasta el punto de control:ROLLBACK TO SAVEPOINT tx_1.
Mientras tanto, la transacción padre física permanece abierta hasta el final mismo de la ejecución de la prueba, garantizando que ni un solo byte de datos se filtre al almacenamiento permanente de la base.
Patrón práctico: sql.OpenDB y t.Cleanup
Antes txdb exigía registrarse en el registro global de drivers mediante txdb.Register. En el Go moderno (a partir de la versión 1.10), la mejor práctica es usar la función sql.OpenDB junto con el conector txdb.New, lo que elimina por completo el estado global:
package repository_test
import (
"context"
"database/sql"
"testing"
"time"
"github.com/DATA-DOG/go-txdb"
_ "github.com/jackc/pgx/v5/stdlib" // driver de PostgreSQL pgx
)
const testDSN = "postgres://postgres:secret@localhost:5432/testdb?sslmode=disable"
// setupTestDB crea un pool aislado de conexiones con rollback garantizado
func setupTestDB(t *testing.T) *sql.DB {
t.Helper()
// Inicializamos el conector txdb sobre pgx
connector := txdb.New("pgx", testDSN)
db := sql.OpenDB(connector)
// Registramos el rollback obligatorio de la transacción al terminar el test
t.Cleanup(func() {
if err := db.Close(); err != nil {
t.Errorf("error al cerrar la conexión txdb: %v", err)
}
})
return db
}
func TestCreateAndFetchUser(t *testing.T) {
db := setupTestDB(t)
ctx := context.Background()
// Inserción de fila en un PostgreSQL real
insertQuery := `INSERT INTO users (email, created_at) VALUES ($1, $2) RETURNING id`
var newID int
err := db.QueryRowContext(ctx, insertQuery, "developer@example.local", time.Now()).Scan(&newID)
if err != nil {
t.Fatalf("no se pudo crear el registro: %v", err)
}
// Lectura de datos dentro de la misma transacción
var fetchedEmail string
selectQuery := `SELECT email FROM users WHERE id = $1`
err = db.QueryRowContext(ctx, selectQuery, newID).Scan(&fetchedEmail)
if err != nil {
t.Fatalf("error al leer el usuario: %v", err)
}
if fetchedEmail != "developer@example.local" {
t.Errorf("se esperaba el email developer@example.local, se obtuvo: %s", fetchedEmail)
}
// Al finalizar la función, t.Cleanup llamará a db.Close() -> ROLLBACK.
// ¡La tabla users en la base testdb quedará cristalina!
}
El segundo ejemplo muestra cómo txdb maneja de forma transparente las llamadas a transacciones anidadas en los servicios:
func TestTransferBalanceWithNestedTransaction(t *testing.T) {
db := setupTestDB(t)
ctx := context.Background()
// La lógica de negocio abre una transacción (txdb la convertirá en SAVEPOINT tx_1)
tx, err := db.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelReadCommitted})
if err != nil {
t.Fatalf("no se pudo abrir la transacción: %v", err)
}
_, err = tx.ExecContext(ctx, `UPDATE accounts SET balance = balance - 100 WHERE id = 1`)
if err != nil {
_ = tx.Rollback()
t.Fatalf("error al descontar fondos: %v", err)
}
// Confirmación de la transacción interna (RELEASE SAVEPOINT tx_1)
if err := tx.Commit(); err != nil {
t.Fatalf("error al confirmar la transacción intermedia: %v", err)
}
}
Escollos y límites de aplicabilidad
A pesar de las ventajas evidentes, txdb tiene límites arquitectónicos que es necesario comprender con claridad:
- DDL no transaccional: en SGBD como MySQL o MariaDB, la ejecución de comandos DDL (
ALTER TABLE,DROP TABLE,CREATE TABLE) provoca una confirmación implícita (implicit commit) de la transacción actual. En PostgreSQL la mayoría de las operaciones DDL son transaccionales, aunque comandos de servicio (VACUUM,CREATE DATABASE) no pueden ejecutarse dentro de transacciones; - Paralelismo dentro de una misma prueba: como todo el test está atado a una única transacción física, txdb serializa las consultas mediante un mutex. Si tu código bajo prueba lanza decenas de goroutines paralelas que escriben activamente en la base, no podrán ejecutarse en conexiones independientes del pool.
En combinación con prácticas modernas como el fuzzing testing en Go, el driver txdb ofrece el equilibrio ideal: la fidelidad de una base de producción real con velocidad de ejecución en microsegundos.

