Seguro que has oído el chiste clásico del programador con un 100 % de cobertura de tests cuyo servicio entra en panic en cuanto pisa producción. Ya comentamos esta ilusión al ver por qué un linter en verde no garantiza la fiabilidad de los tests. En las pruebas unitarias ocurre exactamente lo mismo: ver todo en verde en la terminal no demuestra por sí solo que tus tests sepan cazar bugs.
John Arundel, ingeniero y autor del libro The Power of Go: Tests, resumió esta paradoja de forma clarísima: un test que nunca has visto fallar no merece tu confianza.
Vamos a repasar el ciclo clásico de TDD (Test-Driven Development) con un ejemplo aparentemente trivial: una función IsSorted que comprueba si un slice de enteros está ordenado de menor a mayor.
Programar al revés: del rojo al verde
¿Qué hace quien no usa TDD? Escribe directamente el bucle for, compara elementos y luego añade un test con []int{1, 2, 3}. El test pasa. Todo el mundo contento.
Pero ¿qué pasa si se cuela un error o si la función entera es un simple return true? ¡El test seguiría en verde! Acabamos de fabricar una falsa sensación de seguridad.
En TDD le damos la vuelta al proceso:
- Fase roja (Red). Declaramos la llamada deseada
sorted.IsSorted(input)y escribimos un stub mínimo para que compile devolviendo una respuesta falsa a propósito:return false. Ejecutamosgo testy comprobamos con nuestros propios ojos que falla con un mensaje claro. ¡El test está vivo! - Comprobación simétrica. Añadimos un caso desordenado
[]int{1, 3, 2} -> false. Ahora ninguna constante (trueofalse) podrá engañar al runner de pruebas. - Fase verde (Shameless Green). Escribimos el código más sencillo que haga pasar los tests, aunque parezca ingenuo.
Evolución de los casos límite del algoritmo
Es justo al pasar del código ingenuo a algo listo para producción cuando salen a la luz los tropiezos clásicos del algoritmo:
- Números negativos: si inicializas la variable del valor anterior a cero (
prev := 0), el slice[]int{-1, 2, 3}se marcará por error como desordenado (-1 < 0). Hay que inicializarla siempre con el primer elemento del slice. - Slices vacíos: acceder a
input[0]en un slice vacío[]int{}provoca de inmediato un fallo fatal en tiempo de ejecución:panic: runtime error: index out of range. Hace falta proteger el límite conlen(input) < 2. - Duplicados:
[]int{1, 2, 2}debe considerarse ordenado, así que la condición de fallo es estrictamentev < prev.
Tests en tabla y paralelismo en Go 1.22+
El patrón ideal para este tipo de comprobaciones en Go son los table-driven tests combinados con subtests t.Run y ejecución paralela t.Parallel():
package sorted_test
import (
"testing"
"github.com/example/sorted"
)
func TestIsSorted_TableDriven(t *testing.T) {
t.Parallel()
tests := []struct {
name string
input []int
want bool
}{
{"отсортированный срез", []int{1, 2, 3}, true},
{"повторяющиеся элементы", []int{1, 2, 2}, true},
{"отрицательные числа", []int{-1, 2, 3}, true},
{"пустой срез", []int{}, true},
{"один элемент", []int{42}, true},
{"нарушение в конце", []int{1, 3, 2}, false},
{"обратный порядок", []int{3, 2, 1}, false},
}
for _, tc := range tests {
// En Go 1.22+ ya no hace falta reasignar tc := tc:
// las variables del bucle quedan aisladas en cada iteración
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
got := sorted.IsSorted(tc.input)
if got != tc.want {
t.Errorf("IsSorted(%v) = %v, ожидалось %v", tc.input, got, tc.want)
}
})
}
}
Fase de refactorización: salto a slices.IsSorted
Cuando todos los casos límite están cubiertos por los tests, llega la parte favorita de cualquier ingeniero: refactorizar. ¿Para qué mantener un bucle propio si desde Go 1.21 la librería estándar incluye el paquete genérico slices?
Borramos nuestro código manual y lo sustituimos por la llamada a la función estándar:
package sorted
import "slices"
// IsSorted comprueba si los elementos de cualquier tipo comparable están ordenados
func IsSorted(input []int) bool {
return slices.IsSorted(input)
}
Lanzamos go test -v -race ./... y los siete subtests paralelos brillan en verde. Hemos refactorizado la base de código en un par de segundos con la certeza absoluta de no haber roto ningún caso límite. Ahí es donde está el verdadero superpoder del TDD.


