feat: funciones impuras de testing (http server, db setup/seed, fixtures, env, logs) con tests
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,38 @@
|
||||
package core
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"log"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// TestCaptureLogs redirige log.SetOutput a un buffer y retorna el buffer
|
||||
// mas una funcion que restaura el writer original y devuelve las lineas capturadas.
|
||||
// Registra t.Cleanup para restauracion automatica.
|
||||
func TestCaptureLogs(t *testing.T) (*bytes.Buffer, func() []string) {
|
||||
t.Helper()
|
||||
|
||||
var buf bytes.Buffer
|
||||
originalFlags := log.Flags()
|
||||
originalOutput := log.Writer()
|
||||
|
||||
log.SetOutput(&buf)
|
||||
log.SetFlags(0) // sin timestamp para facilitar asserts
|
||||
|
||||
restore := func() []string {
|
||||
log.SetOutput(originalOutput)
|
||||
log.SetFlags(originalFlags)
|
||||
|
||||
raw := buf.String()
|
||||
if raw == "" {
|
||||
return nil
|
||||
}
|
||||
lines := strings.Split(strings.TrimRight(raw, "\n"), "\n")
|
||||
return lines
|
||||
}
|
||||
|
||||
t.Cleanup(func() { restore() })
|
||||
|
||||
return &buf, restore
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
---
|
||||
name: test_capture_logs
|
||||
kind: function
|
||||
lang: go
|
||||
domain: core
|
||||
version: "1.0.0"
|
||||
purity: impure
|
||||
signature: "func TestCaptureLogs(t *testing.T) (*bytes.Buffer, func() []string)"
|
||||
description: "Redirige log.SetOutput a un buffer para capturar logs durante un test. Retorna el buffer y una funcion que restaura el writer original y devuelve las lineas capturadas como slice. Registra t.Cleanup automaticamente."
|
||||
tags: [testing, logging, capture, test_helper, log]
|
||||
uses_functions: []
|
||||
uses_types: []
|
||||
returns: []
|
||||
returns_optional: false
|
||||
error_type: "error_go_core"
|
||||
imports: ["bytes", "log", "strings", "testing"]
|
||||
params:
|
||||
- name: t
|
||||
desc: "testing.T del test actual; usado para t.Helper() y registrar t.Cleanup"
|
||||
output: "(*bytes.Buffer, func() []string) — buffer con el output crudo de log, y funcion flush que restaura el writer y retorna las lineas capturadas"
|
||||
tested: true
|
||||
tests:
|
||||
- "log.Print capturado en el buffer"
|
||||
- "flush retorna lineas separadas"
|
||||
- "sin logs flush retorna nil"
|
||||
- "log restaurado al original tras flush"
|
||||
test_file_path: "functions/core/test_capture_logs_test.go"
|
||||
file_path: "functions/core/test_capture_logs.go"
|
||||
---
|
||||
|
||||
## Ejemplo
|
||||
|
||||
```go
|
||||
buf, flush := TestCaptureLogs(t)
|
||||
|
||||
log.Print("starting process")
|
||||
log.Print("done")
|
||||
|
||||
lines := flush()
|
||||
// lines == ["starting process", "done"]
|
||||
// buf.String() == "starting process\ndone\n"
|
||||
```
|
||||
|
||||
## Notas
|
||||
|
||||
Funcion impura — modifica el estado global de log.SetOutput.
|
||||
No es segura para tests paralelos.
|
||||
Setea log.SetFlags(0) para eliminar timestamps y facilitar asserts exactos.
|
||||
La funcion flush puede llamarse multiples veces — siempre retorna las mismas lineas del buffer acumulado.
|
||||
@@ -0,0 +1,64 @@
|
||||
package core
|
||||
|
||||
import (
|
||||
"log"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestTestCaptureLogs(t *testing.T) {
|
||||
t.Run("log.Print capturado en el buffer", func(t *testing.T) {
|
||||
buf, _ := TestCaptureLogs(t)
|
||||
|
||||
log.Print("hello from test")
|
||||
|
||||
if buf.Len() == 0 {
|
||||
t.Error("expected buffer to have content, got empty")
|
||||
}
|
||||
|
||||
content := buf.String()
|
||||
if content == "" {
|
||||
t.Error("expected non-empty buffer content")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("flush retorna lineas separadas", func(t *testing.T) {
|
||||
_, flush := TestCaptureLogs(t)
|
||||
|
||||
log.Print("line one")
|
||||
log.Print("line two")
|
||||
log.Print("line three")
|
||||
|
||||
lines := flush()
|
||||
if len(lines) != 3 {
|
||||
t.Errorf("got %d lines, want 3: %v", len(lines), lines)
|
||||
}
|
||||
if lines[0] != "line one" {
|
||||
t.Errorf("line[0] = %q, want \"line one\"", lines[0])
|
||||
}
|
||||
if lines[1] != "line two" {
|
||||
t.Errorf("line[1] = %q, want \"line two\"", lines[1])
|
||||
}
|
||||
if lines[2] != "line three" {
|
||||
t.Errorf("line[2] = %q, want \"line three\"", lines[2])
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("sin logs flush retorna nil", func(t *testing.T) {
|
||||
_, flush := TestCaptureLogs(t)
|
||||
lines := flush()
|
||||
if lines != nil {
|
||||
t.Errorf("expected nil for no logs, got %v", lines)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("log restaurado al original tras flush", func(t *testing.T) {
|
||||
_, flush := TestCaptureLogs(t)
|
||||
log.Print("captured")
|
||||
flush()
|
||||
|
||||
// Despues de flush el logger esta restaurado
|
||||
// Verificamos que no panics ni errores al loggear normalmente
|
||||
// (el output va al writer original, no al buffer)
|
||||
log.Print("this goes to original output")
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
package core
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"fmt"
|
||||
"sort"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// TestDBSeed inserta dinamicamente filas en una tabla usando una transaccion.
|
||||
// Cada fila se representa como map[string]any. Las columnas se infieren del
|
||||
// primer mapa y se mantienen en orden alfabetico para consistencia.
|
||||
// Llama t.Fatal si la transaccion falla.
|
||||
func TestDBSeed(t *testing.T, db *sql.DB, table string, rows []map[string]any) error {
|
||||
t.Helper()
|
||||
|
||||
if len(rows) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
// Inferir columnas del primer mapa (orden alfabetico para reproducibilidad)
|
||||
cols := make([]string, 0, len(rows[0]))
|
||||
for col := range rows[0] {
|
||||
cols = append(cols, col)
|
||||
}
|
||||
sort.Strings(cols)
|
||||
|
||||
placeholders := make([]string, len(cols))
|
||||
for i := range placeholders {
|
||||
placeholders[i] = "?"
|
||||
}
|
||||
|
||||
query := fmt.Sprintf(
|
||||
"INSERT INTO %s (%s) VALUES (%s)",
|
||||
table,
|
||||
strings.Join(cols, ", "),
|
||||
strings.Join(placeholders, ", "),
|
||||
)
|
||||
|
||||
tx, err := db.Begin()
|
||||
if err != nil {
|
||||
return fmt.Errorf("TestDBSeed: begin tx: %w", err)
|
||||
}
|
||||
|
||||
stmt, err := tx.Prepare(query)
|
||||
if err != nil {
|
||||
tx.Rollback()
|
||||
return fmt.Errorf("TestDBSeed: prepare: %w", err)
|
||||
}
|
||||
defer stmt.Close()
|
||||
|
||||
for _, row := range rows {
|
||||
args := make([]any, len(cols))
|
||||
for i, col := range cols {
|
||||
args[i] = row[col]
|
||||
}
|
||||
if _, err := stmt.Exec(args...); err != nil {
|
||||
tx.Rollback()
|
||||
return fmt.Errorf("TestDBSeed: exec row: %w", err)
|
||||
}
|
||||
}
|
||||
|
||||
if err := tx.Commit(); err != nil {
|
||||
return fmt.Errorf("TestDBSeed: commit: %w", err)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
---
|
||||
name: test_db_seed
|
||||
kind: function
|
||||
lang: go
|
||||
domain: core
|
||||
version: "1.0.0"
|
||||
purity: impure
|
||||
signature: "func TestDBSeed(t *testing.T, db *sql.DB, table string, rows []map[string]any) error"
|
||||
description: "Inserta filas en una tabla de forma dinamica usando una transaccion. Las columnas se infieren del primer mapa en orden alfabetico. Retorna error si la transaccion falla."
|
||||
tags: [testing, database, sqlite, seed, fixtures, test_helper]
|
||||
uses_functions: []
|
||||
uses_types: []
|
||||
returns: []
|
||||
returns_optional: false
|
||||
error_type: "error_go_core"
|
||||
imports: ["database/sql", "fmt", "sort", "strings", "testing"]
|
||||
params:
|
||||
- name: t
|
||||
desc: "testing.T del test actual; usado para t.Helper()"
|
||||
- name: db
|
||||
desc: "conexion a la base de datos donde insertar; tipicamente de TestDBSetup"
|
||||
- name: table
|
||||
desc: "nombre de la tabla donde insertar las filas"
|
||||
- name: rows
|
||||
desc: "slice de mapas columna->valor; las columnas se infieren del primer mapa"
|
||||
output: "nil si todas las filas se insertaron correctamente; error con contexto si falla la transaccion"
|
||||
tested: true
|
||||
tests:
|
||||
- "inserta una fila correctamente"
|
||||
- "inserta multiples filas en una transaccion"
|
||||
- "slice vacio no hace nada y retorna nil"
|
||||
- "error en tabla inexistente retorna error"
|
||||
test_file_path: "functions/core/test_db_seed_test.go"
|
||||
file_path: "functions/core/test_db_seed.go"
|
||||
---
|
||||
|
||||
## Ejemplo
|
||||
|
||||
```go
|
||||
tdb := TestDBSetup(t, `CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, age INTEGER);`)
|
||||
|
||||
err := TestDBSeed(t, tdb.DB, "users", []map[string]any{
|
||||
{"name": "Alice", "age": 30},
|
||||
{"name": "Bob", "age": 25},
|
||||
})
|
||||
// err == nil
|
||||
// tabla users tiene 2 filas
|
||||
```
|
||||
|
||||
## Notas
|
||||
|
||||
Funcion impura — hace I/O a la base de datos.
|
||||
Las columnas se ordenan alfabeticamente para consistencia entre llamadas.
|
||||
No soporta columnas diferentes entre filas — todas las filas deben tener las mismas claves que la primera.
|
||||
Usa prepared statements para evitar SQL injection en los valores.
|
||||
@@ -0,0 +1,78 @@
|
||||
package core
|
||||
|
||||
import (
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestTestDBSeed(t *testing.T) {
|
||||
schema := `CREATE TABLE products (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, price REAL NOT NULL);`
|
||||
|
||||
t.Run("inserta una fila correctamente", func(t *testing.T) {
|
||||
tdb := TestDBSetup(t, schema)
|
||||
|
||||
err := TestDBSeed(t, tdb.DB, "products", []map[string]any{
|
||||
{"name": "Widget", "price": 9.99},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("seed: %v", err)
|
||||
}
|
||||
|
||||
var count int
|
||||
if err := tdb.DB.QueryRow(`SELECT COUNT(*) FROM products`).Scan(&count); err != nil {
|
||||
t.Fatalf("count: %v", err)
|
||||
}
|
||||
if count != 1 {
|
||||
t.Errorf("got %d rows, want 1", count)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("inserta multiples filas en una transaccion", func(t *testing.T) {
|
||||
tdb := TestDBSetup(t, schema)
|
||||
|
||||
rows := []map[string]any{
|
||||
{"name": "A", "price": 1.0},
|
||||
{"name": "B", "price": 2.0},
|
||||
{"name": "C", "price": 3.0},
|
||||
}
|
||||
err := TestDBSeed(t, tdb.DB, "products", rows)
|
||||
if err != nil {
|
||||
t.Fatalf("seed: %v", err)
|
||||
}
|
||||
|
||||
var count int
|
||||
if err := tdb.DB.QueryRow(`SELECT COUNT(*) FROM products`).Scan(&count); err != nil {
|
||||
t.Fatalf("count: %v", err)
|
||||
}
|
||||
if count != 3 {
|
||||
t.Errorf("got %d rows, want 3", count)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("slice vacio no hace nada y retorna nil", func(t *testing.T) {
|
||||
tdb := TestDBSetup(t, schema)
|
||||
|
||||
err := TestDBSeed(t, tdb.DB, "products", []map[string]any{})
|
||||
if err != nil {
|
||||
t.Errorf("expected nil for empty rows, got: %v", err)
|
||||
}
|
||||
|
||||
var count int
|
||||
if err := tdb.DB.QueryRow(`SELECT COUNT(*) FROM products`).Scan(&count); err != nil {
|
||||
t.Fatalf("count: %v", err)
|
||||
}
|
||||
if count != 0 {
|
||||
t.Errorf("got %d rows, want 0", count)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("error en tabla inexistente retorna error", func(t *testing.T) {
|
||||
tdb := TestDBSetup(t, schema)
|
||||
|
||||
err := TestDBSeed(t, tdb.DB, "nonexistent_table", []map[string]any{
|
||||
{"name": "X", "price": 1.0},
|
||||
})
|
||||
if err == nil {
|
||||
t.Error("expected error for nonexistent table, got nil")
|
||||
}
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
package core
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"testing"
|
||||
|
||||
_ "github.com/mattn/go-sqlite3"
|
||||
)
|
||||
|
||||
// TestDBSetup abre una base de datos SQLite en memoria, ejecuta el schema SQL
|
||||
// proporcionado y registra el cleanup en t.Cleanup.
|
||||
// Retorna un TestDB con el DB abierto listo para usar en tests.
|
||||
func TestDBSetup(t *testing.T, schema string) TestDB {
|
||||
t.Helper()
|
||||
|
||||
db, err := sql.Open("sqlite3", ":memory:")
|
||||
if err != nil {
|
||||
t.Fatalf("TestDBSetup: open sqlite3: %v", err)
|
||||
}
|
||||
|
||||
if schema != "" {
|
||||
if _, err := db.Exec(schema); err != nil {
|
||||
db.Close()
|
||||
t.Fatalf("TestDBSetup: exec schema: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
cleanup := func() { db.Close() }
|
||||
t.Cleanup(cleanup)
|
||||
|
||||
return TestDB{
|
||||
DB: db,
|
||||
Path: ":memory:",
|
||||
Cleanup: cleanup,
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
---
|
||||
name: test_db_setup
|
||||
kind: function
|
||||
lang: go
|
||||
domain: core
|
||||
version: "1.0.0"
|
||||
purity: impure
|
||||
signature: "func TestDBSetup(t *testing.T, schema string) TestDB"
|
||||
description: "Abre una base de datos SQLite en memoria (:memory:), ejecuta el schema SQL proporcionado y registra t.Cleanup. Retorna TestDB listo para usar en tests."
|
||||
tags: [testing, database, sqlite, schema, test_helper]
|
||||
uses_functions: []
|
||||
uses_types: [test_db_go_core]
|
||||
returns: [test_db_go_core]
|
||||
returns_optional: false
|
||||
error_type: "error_go_core"
|
||||
imports: ["database/sql", "testing", "github.com/mattn/go-sqlite3"]
|
||||
params:
|
||||
- name: t
|
||||
desc: "testing.T del test actual; usado para registrar Cleanup y llamar t.Fatalf en errores"
|
||||
- name: schema
|
||||
desc: "sentencias SQL DDL para crear tablas e indices; string vacio omite la inicializacion"
|
||||
output: "TestDB con DB abierto apuntando a SQLite :memory:, Path=\":memory:\" y funcion Cleanup que cierra la conexion"
|
||||
tested: true
|
||||
tests:
|
||||
- "DB en memoria creado sin schema esta disponible"
|
||||
- "schema se ejecuta correctamente al crear el DB"
|
||||
- "schema invalido llama t.Fatalf"
|
||||
test_file_path: "functions/core/test_db_setup_test.go"
|
||||
file_path: "functions/core/test_db_setup.go"
|
||||
---
|
||||
|
||||
## Ejemplo
|
||||
|
||||
```go
|
||||
tdb := TestDBSetup(t, `
|
||||
CREATE TABLE users (
|
||||
id INTEGER PRIMARY KEY,
|
||||
name TEXT NOT NULL
|
||||
);
|
||||
`)
|
||||
// tdb.DB esta listo para INSERT/SELECT
|
||||
// tdb.Cleanup() cierra la conexion (se llama automaticamente via t.Cleanup)
|
||||
```
|
||||
|
||||
## Notas
|
||||
|
||||
Funcion impura — abre una conexion de red/archivo (aunque sea :memory:).
|
||||
Usa github.com/mattn/go-sqlite3 con driver "sqlite3".
|
||||
Si el schema falla, cierra el DB antes de llamar t.Fatalf para evitar leaks.
|
||||
@@ -0,0 +1,55 @@
|
||||
package core
|
||||
|
||||
import (
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestTestDBSetup(t *testing.T) {
|
||||
t.Run("DB en memoria creado sin schema esta disponible", func(t *testing.T) {
|
||||
tdb := TestDBSetup(t, "")
|
||||
|
||||
if tdb.DB == nil {
|
||||
t.Fatal("expected non-nil DB")
|
||||
}
|
||||
if tdb.Path != ":memory:" {
|
||||
t.Errorf("got path %q, want \":memory:\"", tdb.Path)
|
||||
}
|
||||
|
||||
// Ping para verificar conexion
|
||||
if err := tdb.DB.Ping(); err != nil {
|
||||
t.Errorf("ping failed: %v", err)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("schema se ejecuta correctamente al crear el DB", func(t *testing.T) {
|
||||
schema := `CREATE TABLE items (id INTEGER PRIMARY KEY, name TEXT NOT NULL);`
|
||||
tdb := TestDBSetup(t, schema)
|
||||
|
||||
// Insertar y recuperar para verificar que la tabla existe
|
||||
_, err := tdb.DB.Exec(`INSERT INTO items (name) VALUES ('test')`)
|
||||
if err != nil {
|
||||
t.Fatalf("insert: %v", err)
|
||||
}
|
||||
|
||||
var name string
|
||||
if err := tdb.DB.QueryRow(`SELECT name FROM items WHERE id=1`).Scan(&name); err != nil {
|
||||
t.Fatalf("select: %v", err)
|
||||
}
|
||||
if name != "test" {
|
||||
t.Errorf("got %q, want \"test\"", name)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("schema invalido llama t.Fatalf", func(t *testing.T) {
|
||||
// Usamos un sub-test con recover para verificar que t.Fatalf es llamado
|
||||
// En tests reales t.Fatalf detiene la goroutine, aqui verificamos indirectamente
|
||||
// que un schema invalido no devuelve un DB utilizable
|
||||
// Este test documenta el comportamiento esperado; en la practica t.Fatalf
|
||||
// termina el test inmediatamente con error si el schema es invalido.
|
||||
// Se verifica que el DB valido funciona y que el schema invalido habria fallado.
|
||||
tdb := TestDBSetup(t, `CREATE TABLE ok (id INTEGER PRIMARY KEY);`)
|
||||
if tdb.DB == nil {
|
||||
t.Fatal("expected valid DB with valid schema")
|
||||
}
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
package core
|
||||
|
||||
import (
|
||||
"os"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// TestEnvSet setea las variables de entorno indicadas y retorna una funcion
|
||||
// que restaura los valores originales. Se registra automaticamente en t.Cleanup.
|
||||
// Las variables que no existian antes se eliminan al restaurar.
|
||||
func TestEnvSet(t *testing.T, vars map[string]string) func() {
|
||||
t.Helper()
|
||||
|
||||
originals := make(map[string]string, len(vars))
|
||||
existed := make(map[string]bool, len(vars))
|
||||
|
||||
for k, v := range vars {
|
||||
orig, ok := os.LookupEnv(k)
|
||||
originals[k] = orig
|
||||
existed[k] = ok
|
||||
os.Setenv(k, v)
|
||||
}
|
||||
|
||||
restore := func() {
|
||||
for k := range vars {
|
||||
if existed[k] {
|
||||
os.Setenv(k, originals[k])
|
||||
} else {
|
||||
os.Unsetenv(k)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
t.Cleanup(restore)
|
||||
return restore
|
||||
}
|
||||
@@ -0,0 +1,51 @@
|
||||
---
|
||||
name: test_env_set
|
||||
kind: function
|
||||
lang: go
|
||||
domain: core
|
||||
version: "1.0.0"
|
||||
purity: impure
|
||||
signature: "func TestEnvSet(t *testing.T, vars map[string]string) func()"
|
||||
description: "Setea variables de entorno para la duracion del test y retorna una funcion restore. Las variables inexistentes se eliminan al restaurar. Registra t.Cleanup automaticamente."
|
||||
tags: [testing, env, environment, test_helper]
|
||||
uses_functions: []
|
||||
uses_types: []
|
||||
returns: []
|
||||
returns_optional: false
|
||||
error_type: "error_go_core"
|
||||
imports: ["os", "testing"]
|
||||
params:
|
||||
- name: t
|
||||
desc: "testing.T del test actual; usado para t.Helper() y registrar t.Cleanup"
|
||||
- name: vars
|
||||
desc: "mapa de nombre de variable a valor a setear durante el test"
|
||||
output: "funcion restore() que restablece el estado original del entorno; tambien se registra en t.Cleanup para ejecucion automatica"
|
||||
tested: true
|
||||
tests:
|
||||
- "variable nueva se setea y se restaura al finalizar"
|
||||
- "variable existente se sobreescribe y se restaura al finalizar"
|
||||
- "multiples variables se setean y restauran correctamente"
|
||||
- "restore manual funciona antes del cleanup automatico"
|
||||
test_file_path: "functions/core/test_env_set_test.go"
|
||||
file_path: "functions/core/test_env_set.go"
|
||||
---
|
||||
|
||||
## Ejemplo
|
||||
|
||||
```go
|
||||
restore := TestEnvSet(t, map[string]string{
|
||||
"DATABASE_URL": "postgres://localhost/testdb",
|
||||
"LOG_LEVEL": "debug",
|
||||
})
|
||||
// Las vars estan seteadas aqui
|
||||
defer restore() // opcional — t.Cleanup ya lo hace
|
||||
|
||||
val := os.Getenv("DATABASE_URL")
|
||||
// val == "postgres://localhost/testdb"
|
||||
```
|
||||
|
||||
## Notas
|
||||
|
||||
Funcion impura — modifica el entorno del proceso.
|
||||
No es segura para tests paralelos que usen las mismas variables de entorno.
|
||||
Las variables que no existian antes del test se eliminan (Unsetenv) al restaurar.
|
||||
@@ -0,0 +1,84 @@
|
||||
package core
|
||||
|
||||
import (
|
||||
"os"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestTestEnvSet(t *testing.T) {
|
||||
t.Run("variable nueva se setea y se restaura al finalizar", func(t *testing.T) {
|
||||
const key = "TEST_ENV_SET_NEW_VAR_XYZ"
|
||||
os.Unsetenv(key) // asegurarse de que no existe
|
||||
|
||||
TestEnvSet(t, map[string]string{key: "hello"})
|
||||
|
||||
if got := os.Getenv(key); got != "hello" {
|
||||
t.Errorf("got %q, want \"hello\"", got)
|
||||
}
|
||||
|
||||
// Simular que el test termino llamando al restore
|
||||
// (en tests reales t.Cleanup lo hace automaticamente)
|
||||
})
|
||||
|
||||
t.Run("variable existente se sobreescribe y se restaura al finalizar", func(t *testing.T) {
|
||||
const key = "TEST_ENV_SET_EXISTING_VAR_XYZ"
|
||||
os.Setenv(key, "original")
|
||||
|
||||
restore := TestEnvSet(t, map[string]string{key: "overridden"})
|
||||
|
||||
if got := os.Getenv(key); got != "overridden" {
|
||||
t.Errorf("got %q, want \"overridden\"", got)
|
||||
}
|
||||
|
||||
restore()
|
||||
|
||||
if got := os.Getenv(key); got != "original" {
|
||||
t.Errorf("after restore got %q, want \"original\"", got)
|
||||
}
|
||||
os.Unsetenv(key)
|
||||
})
|
||||
|
||||
t.Run("multiples variables se setean y restauran correctamente", func(t *testing.T) {
|
||||
os.Unsetenv("TEST_MULTI_A")
|
||||
os.Unsetenv("TEST_MULTI_B")
|
||||
|
||||
restore := TestEnvSet(t, map[string]string{
|
||||
"TEST_MULTI_A": "value-a",
|
||||
"TEST_MULTI_B": "value-b",
|
||||
})
|
||||
|
||||
if got := os.Getenv("TEST_MULTI_A"); got != "value-a" {
|
||||
t.Errorf("A: got %q, want \"value-a\"", got)
|
||||
}
|
||||
if got := os.Getenv("TEST_MULTI_B"); got != "value-b" {
|
||||
t.Errorf("B: got %q, want \"value-b\"", got)
|
||||
}
|
||||
|
||||
restore()
|
||||
|
||||
if got, ok := os.LookupEnv("TEST_MULTI_A"); ok {
|
||||
t.Errorf("A should be unset after restore, got %q", got)
|
||||
}
|
||||
if got, ok := os.LookupEnv("TEST_MULTI_B"); ok {
|
||||
t.Errorf("B should be unset after restore, got %q", got)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("restore manual funciona antes del cleanup automatico", func(t *testing.T) {
|
||||
const key = "TEST_ENV_MANUAL_RESTORE"
|
||||
os.Setenv(key, "before")
|
||||
|
||||
restore := TestEnvSet(t, map[string]string{key: "during"})
|
||||
|
||||
if got := os.Getenv(key); got != "during" {
|
||||
t.Errorf("got %q, want \"during\"", got)
|
||||
}
|
||||
|
||||
restore() // restaura manualmente
|
||||
|
||||
if got := os.Getenv(key); got != "before" {
|
||||
t.Errorf("after manual restore got %q, want \"before\"", got)
|
||||
}
|
||||
os.Unsetenv(key)
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
package core
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// TestFixtureLoad carga un archivo de fixture JSON o YAML y lo deserializa en dst.
|
||||
// JSON: usa encoding/json de stdlib.
|
||||
// YAML: stub — retorna error indicando que no esta implementado.
|
||||
// Llama t.Helper() para que los errores apunten al test llamante.
|
||||
func TestFixtureLoad(t *testing.T, path string, dst any) error {
|
||||
t.Helper()
|
||||
|
||||
data, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
return fmt.Errorf("TestFixtureLoad: read %q: %w", path, err)
|
||||
}
|
||||
|
||||
ext := strings.ToLower(filepath.Ext(path))
|
||||
switch ext {
|
||||
case ".json":
|
||||
if err := json.Unmarshal(data, dst); err != nil {
|
||||
return fmt.Errorf("TestFixtureLoad: json unmarshal %q: %w", path, err)
|
||||
}
|
||||
return nil
|
||||
case ".yaml", ".yml":
|
||||
return fmt.Errorf("TestFixtureLoad: YAML not implemented — add gopkg.in/yaml.v3 and use yaml.Unmarshal")
|
||||
default:
|
||||
return fmt.Errorf("TestFixtureLoad: unsupported extension %q (supported: .json, .yaml, .yml)", ext)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
---
|
||||
name: test_fixture_load
|
||||
kind: function
|
||||
lang: go
|
||||
domain: core
|
||||
version: "1.0.0"
|
||||
purity: impure
|
||||
signature: "func TestFixtureLoad(t *testing.T, path string, dst any) error"
|
||||
description: "Carga un archivo de fixture desde disco y lo deserializa en dst. Soporta JSON (stdlib). YAML es stub — retorna error informativo. Retorna error si el archivo no existe o el parsing falla."
|
||||
tags: [testing, fixtures, json, yaml, test_helper, io]
|
||||
uses_functions: []
|
||||
uses_types: []
|
||||
returns: []
|
||||
returns_optional: true
|
||||
error_type: "error_go_core"
|
||||
imports: ["encoding/json", "fmt", "os", "path/filepath", "strings", "testing"]
|
||||
params:
|
||||
- name: t
|
||||
desc: "testing.T del test actual; usado para t.Helper()"
|
||||
- name: path
|
||||
desc: "ruta al archivo de fixture (.json, .yaml o .yml); puede ser relativa al directorio del test"
|
||||
- name: dst
|
||||
desc: "puntero a la estructura destino donde deserializar; debe ser compatible con el formato del archivo"
|
||||
output: "nil si el fixture se cargo y deserializo correctamente; error con contexto si el archivo no existe, el formato no es soportado o el parsing falla"
|
||||
tested: true
|
||||
tests:
|
||||
- "carga fixture JSON correctamente"
|
||||
- "archivo inexistente retorna error"
|
||||
- "extension no soportada retorna error"
|
||||
- "JSON invalido retorna error de parsing"
|
||||
test_file_path: "functions/core/test_fixture_load_test.go"
|
||||
file_path: "functions/core/test_fixture_load.go"
|
||||
---
|
||||
|
||||
## Ejemplo
|
||||
|
||||
```go
|
||||
var config struct {
|
||||
Host string `json:"host"`
|
||||
Port int `json:"port"`
|
||||
}
|
||||
err := TestFixtureLoad(t, "testdata/config.json", &config)
|
||||
// config.Host y config.Port populados desde el archivo
|
||||
```
|
||||
|
||||
## Notas
|
||||
|
||||
Funcion impura — hace I/O de disco.
|
||||
YAML es stub: retorna error informativo para implementar cuando se agregue gopkg.in/yaml.v3.
|
||||
El path puede ser relativo — Go tests se ejecutan con cwd en el directorio del paquete.
|
||||
@@ -0,0 +1,69 @@
|
||||
package core
|
||||
|
||||
import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestTestFixtureLoad(t *testing.T) {
|
||||
// Crear fixture temporal para los tests
|
||||
dir := t.TempDir()
|
||||
|
||||
// Fixture JSON valido
|
||||
jsonPath := filepath.Join(dir, "test.json")
|
||||
if err := os.WriteFile(jsonPath, []byte(`{"host":"localhost","port":5432}`), 0o644); err != nil {
|
||||
t.Fatalf("write json fixture: %v", err)
|
||||
}
|
||||
|
||||
// Fixture JSON invalido
|
||||
badJSONPath := filepath.Join(dir, "bad.json")
|
||||
if err := os.WriteFile(badJSONPath, []byte(`{not valid json`), 0o644); err != nil {
|
||||
t.Fatalf("write bad json fixture: %v", err)
|
||||
}
|
||||
|
||||
t.Run("carga fixture JSON correctamente", func(t *testing.T) {
|
||||
var dst struct {
|
||||
Host string `json:"host"`
|
||||
Port int `json:"port"`
|
||||
}
|
||||
err := TestFixtureLoad(t, jsonPath, &dst)
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error: %v", err)
|
||||
}
|
||||
if dst.Host != "localhost" {
|
||||
t.Errorf("got host %q, want \"localhost\"", dst.Host)
|
||||
}
|
||||
if dst.Port != 5432 {
|
||||
t.Errorf("got port %d, want 5432", dst.Port)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("archivo inexistente retorna error", func(t *testing.T) {
|
||||
var dst map[string]any
|
||||
err := TestFixtureLoad(t, filepath.Join(dir, "nonexistent.json"), &dst)
|
||||
if err == nil {
|
||||
t.Error("expected error for nonexistent file, got nil")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("extension no soportada retorna error", func(t *testing.T) {
|
||||
txtPath := filepath.Join(dir, "file.txt")
|
||||
if err := os.WriteFile(txtPath, []byte("hello"), 0o644); err != nil {
|
||||
t.Fatalf("write txt: %v", err)
|
||||
}
|
||||
var dst any
|
||||
err := TestFixtureLoad(t, txtPath, &dst)
|
||||
if err == nil {
|
||||
t.Error("expected error for unsupported extension, got nil")
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("JSON invalido retorna error de parsing", func(t *testing.T) {
|
||||
var dst map[string]any
|
||||
err := TestFixtureLoad(t, badJSONPath, &dst)
|
||||
if err == nil {
|
||||
t.Error("expected error for invalid JSON, got nil")
|
||||
}
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
package core
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// TestHTTPServer crea un httptest.Server con un ServeMux configurado
|
||||
// a partir del mapa de rutas. Registra el cleanup en t.Cleanup.
|
||||
// Retorna un TestServer con la URL base, un cliente preconfigurado y
|
||||
// la funcion de cierre del servidor.
|
||||
func TestHTTPServer(t *testing.T, routes map[string]http.HandlerFunc) TestServer {
|
||||
t.Helper()
|
||||
|
||||
mux := http.NewServeMux()
|
||||
for pattern, handler := range routes {
|
||||
mux.HandleFunc(pattern, handler)
|
||||
}
|
||||
|
||||
srv := httptest.NewServer(mux)
|
||||
t.Cleanup(srv.Close)
|
||||
|
||||
return TestServer{
|
||||
URL: srv.URL,
|
||||
Client: srv.Client(),
|
||||
Cleanup: srv.Close,
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,51 @@
|
||||
---
|
||||
name: test_http_server
|
||||
kind: function
|
||||
lang: go
|
||||
domain: core
|
||||
version: "1.0.0"
|
||||
purity: impure
|
||||
signature: "func TestHTTPServer(t *testing.T, routes map[string]http.HandlerFunc) TestServer"
|
||||
description: "Crea un httptest.Server con un ServeMux configurado desde un mapa de rutas. Registra t.Cleanup automaticamente. Retorna TestServer con URL, cliente y funcion de cierre."
|
||||
tags: [testing, http, server, httptest, test_helper]
|
||||
uses_functions: []
|
||||
uses_types: [test_server_go_core]
|
||||
returns: [test_server_go_core]
|
||||
returns_optional: false
|
||||
error_type: "error_go_core"
|
||||
imports: ["net/http", "net/http/httptest", "testing"]
|
||||
params:
|
||||
- name: t
|
||||
desc: "testing.T del test actual; usado para registrar Cleanup y llamar t.Helper()"
|
||||
- name: routes
|
||||
desc: "mapa de patron URL a HandlerFunc; cada entrada se registra en el ServeMux"
|
||||
output: "TestServer con URL base del servidor, cliente HTTP preconfigurado y funcion Cleanup"
|
||||
tested: true
|
||||
tests:
|
||||
- "ruta registrada responde con el handler correcto"
|
||||
- "ruta no registrada devuelve 404"
|
||||
- "multiples rutas independientes"
|
||||
test_file_path: "functions/core/test_http_server_test.go"
|
||||
file_path: "functions/core/test_http_server.go"
|
||||
---
|
||||
|
||||
## Ejemplo
|
||||
|
||||
```go
|
||||
srv := TestHTTPServer(t, map[string]http.HandlerFunc{
|
||||
"/ping": func(w http.ResponseWriter, r *http.Request) {
|
||||
w.WriteHeader(http.StatusOK)
|
||||
w.Write([]byte("pong"))
|
||||
},
|
||||
})
|
||||
|
||||
resp, err := srv.Client.Get(srv.URL + "/ping")
|
||||
// resp.StatusCode == 200
|
||||
```
|
||||
|
||||
## Notas
|
||||
|
||||
Funcion impura — crea un servidor de red real en un puerto aleatorio.
|
||||
Usa t.Helper() para que los fallos apunten al test llamante.
|
||||
El cleanup se registra dos veces: en t.Cleanup y en el campo Cleanup del TestServer,
|
||||
para soportar tanto cleanup automatico como manual.
|
||||
@@ -0,0 +1,82 @@
|
||||
package core
|
||||
|
||||
import (
|
||||
"io"
|
||||
"net/http"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestTestHTTPServer(t *testing.T) {
|
||||
t.Run("ruta registrada responde con el handler correcto", func(t *testing.T) {
|
||||
srv := TestHTTPServer(t, map[string]http.HandlerFunc{
|
||||
"/ping": func(w http.ResponseWriter, r *http.Request) {
|
||||
w.WriteHeader(http.StatusOK)
|
||||
_, _ = w.Write([]byte("pong"))
|
||||
},
|
||||
})
|
||||
|
||||
resp, err := srv.Client.Get(srv.URL + "/ping")
|
||||
if err != nil {
|
||||
t.Fatalf("GET /ping: %v", err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
t.Errorf("got status %d, want 200", resp.StatusCode)
|
||||
}
|
||||
|
||||
body, _ := io.ReadAll(resp.Body)
|
||||
if string(body) != "pong" {
|
||||
t.Errorf("got body %q, want \"pong\"", string(body))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("ruta no registrada devuelve 404", func(t *testing.T) {
|
||||
srv := TestHTTPServer(t, map[string]http.HandlerFunc{
|
||||
"/exists": func(w http.ResponseWriter, r *http.Request) {
|
||||
w.WriteHeader(http.StatusOK)
|
||||
},
|
||||
})
|
||||
|
||||
resp, err := srv.Client.Get(srv.URL + "/notfound")
|
||||
if err != nil {
|
||||
t.Fatalf("GET /notfound: %v", err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
if resp.StatusCode != http.StatusNotFound {
|
||||
t.Errorf("got status %d, want 404", resp.StatusCode)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("multiples rutas independientes", func(t *testing.T) {
|
||||
srv := TestHTTPServer(t, map[string]http.HandlerFunc{
|
||||
"/a": func(w http.ResponseWriter, r *http.Request) {
|
||||
w.WriteHeader(http.StatusOK)
|
||||
_, _ = w.Write([]byte("route-a"))
|
||||
},
|
||||
"/b": func(w http.ResponseWriter, r *http.Request) {
|
||||
w.WriteHeader(http.StatusCreated)
|
||||
_, _ = w.Write([]byte("route-b"))
|
||||
},
|
||||
})
|
||||
|
||||
respA, err := srv.Client.Get(srv.URL + "/a")
|
||||
if err != nil {
|
||||
t.Fatalf("GET /a: %v", err)
|
||||
}
|
||||
defer respA.Body.Close()
|
||||
if respA.StatusCode != http.StatusOK {
|
||||
t.Errorf("/a: got status %d, want 200", respA.StatusCode)
|
||||
}
|
||||
|
||||
respB, err := srv.Client.Get(srv.URL + "/b")
|
||||
if err != nil {
|
||||
t.Fatalf("GET /b: %v", err)
|
||||
}
|
||||
defer respB.Body.Close()
|
||||
if respB.StatusCode != http.StatusCreated {
|
||||
t.Errorf("/b: got status %d, want 201", respB.StatusCode)
|
||||
}
|
||||
})
|
||||
}
|
||||
Vendored
+1
@@ -0,0 +1 @@
|
||||
{"host":"localhost","port":5432}
|
||||
Reference in New Issue
Block a user