Regresión agresiva
· 17 min read
testing elixir programming opinion ai llm hacking
Existe una especie particular de ingeniero que, al ser preguntado sobre si la base de código tiene tests de regresión, responde: «tenemos un noventa y cuatro por ciento de cobertura». Esto equivale más o menos a responder a la pregunta «¿está tu casa asegurada contra incendios?» con «tengo once detectores de humo y les saco brillo cada semana». Ambas afirmaciones habitan en la misma vecindad general de inquietudes, pero ni siquiera están lejanamente emparentadas, y solo una de ellas importará la noche en que la cocina arda en llamas.
Permítaseme plantear la tesis de partida, con la esperanza de que sobreviva intacta a su viaje hacia la sección de comentarios:
Cada test de regresión es un test, pero no todo test es un test de regresión.
Esto no es un aforismo ingenioso. Es una afirmación sobre conjuntos, y es la clase de afirmación ante la que la mayoría de los equipos asiente complaciente para luego pisotearla de inmediato durante los siguientes cuatro años.
La taxonomía que nadie se molestó en aprender
Un test es cualquier fragmento de código que falla cuando algo va mal. Un test de regresión es un fragmento de código que falla cuando algo que solía funcionar deja de funcionar. La segunda categoría es un subconjunto estricto de la primera, y es un subconjunto infinitamente menor de lo que insinúa tu insignia de cobertura.
La distinción reside por entero en el verbo «solía». Un test de regresión es un monumento conmemorativo. Rememora un momento específico de la historia en el que el software era demostrablemente correcto, y hace guardia sobre ese instante mientras el proyecto conserve el aliento. Es, en el sentido más literal, memoria institucional codificada como un artefacto ejecutable; lo que la convierte en la única clase de memoria de tu equipo que no dimite, no se jubila ni lo olvida todo tras un fin de semana largo.
La mayor parte de lo que escribimos no es eso. La mayor parte de lo que escribimos es un desarrollador tranquilizándose a sí mismo, a las dos de la tarde, de que la función que acaba de teclear hace lo que pensaba que debía hacer mientras la tecleaba. Es una actividad perfectamente respetable. También es una tautología con bata de laboratorio.
Los tests unitarios son casi siempre espejos
He aquí la verdad incómoda sobre el test unitario promedio: afirma que la implementación hace lo que la implementación hace. El autor escribió la función, luego escribió un test derivado de la función que acababa de parir y después expresó sorpresa cuando ambos coincidieron. Jamás iban a discrepar. Fueron concebidos en los mismos cinco minutos, por el mismo cerebro, bajo el mismo malentendido. Incluso un desarrollador mediocre como yo es capaz de escribir una función sencilla sin pifiarla.
Un test unitario suele meter las manos hasta el fondo. Conoce las funciones auxiliares privadas del módulo, la forma de su acumulador intermedio, el orden exacto en que recorre una lista. Tiene intimidad con detalles que ningún cliente del código observará jamás, y por tanto es frágil exactamente en los lugares donde más desearías libertad de movimientos. Refactoriza el acumulador de una lista a un mapa, sin cambiar absolutamente nada del comportamiento observable, y contempla cómo cuarenta tests se tiñen de rojo mientras el software permanece impoluto. Eso no es una red de seguridad. Es un cable trampa que has instalado en tu propio pasillo.
Y todo el edificio descansa sobre la imaginación del autor. El test unitario comprueba las tres entradas en las que casualmente pensó. El error, con el instinto infalible de un gato que localiza a la única persona alérgica en la habitación, reside en la cuarta.
Por eso un solo test basado en propiedades vale más que un celemín de ejemplos tecleados a mano. En lugar de enumerar lo que se te ocurrió por azar, declaras la ley que la función debe obedecer y dejas que la máquina busque el contraejemplo con una diligencia de la que ningún ser humano dispone a las cuatro de la tarde de un viernes.
Considera el enfoque artesanal habitual:
test "encodes and decodes" do
assert "abc" == decode(encode("abc"))
assert "" == decode(encode(""))
assert "hello world" == decode(encode("hello world"))
end
Tres aserciones, todas elegidas por un ser humano que ya sabía de antemano cómo funcionaba el codificador. Compara con esto:
property "decode/1 is the left inverse of encode/1" do
check all input <- StreamData.string(:printable) do
assert input == input |> encode() |> decode()
end
end
Una sola declaración, infinitas aserciones y —esta es la parte que la gente subestima— un reductor automático ( shrinker ) que te entregará la entrada fallida mínima en lugar del vómito de 4 KiB que generó el fallo original. Eso sí es un perro guardián. Lo otro es una foto de un perro pegada a la cancela.
Elixir no te deja probar funciones privadas, y esto es una bendición
Cada pocos meses, alguien aterriza en los foros con una pregunta redactada como un informe de error: «¿Cómo pruebo una
defp
?». Las respuestas son pacientes y quien pregunta rara vez queda satisfecho, porque la respuesta honesta suena a obstruccionismo:
no lo haces, y no deberías querer hacerlo.
Una función privada, por construcción, no forma parte de tu contrato. Es un andamio. Existe porque te cansaste de una función de cuarenta líneas y la partiste en dos, o porque necesitabas las mismas tres líneas dos veces. Nadie fuera del módulo puede llamarla, nadie fuera del módulo puede observarla y nadie fuera del módulo se verá perjudicado si la reemplazas. No tiene comportamiento en el sentido que importa: solo tiene implementación, y la implementación es precisamente lo que acabamos de acordar no probar.
El lenguaje no está haciéndose el remolón. Te está diciendo algo: si sientes una necesidad imperiosa de probar una función privada de forma aislada, has descubierto una tensión de diseño, no una carencia de las herramientas. Una de estas tres cosas es cierta:
Debería ser pública. Lo que intentas acorralar es en realidad parte del contrato del módulo, y has estado ocultándote tu propia API a ti mismo por un equivocado sentido del orden. Hazla pública, documéntala y pruébala como la entidad pública que siempre fue.
Debería ser un módulo propio. El asistente privado ha desarrollado personalidad: su propio vocabulario, sus propios invariantes, sus propios motivos para cambiar. Es un módulo intentando nacer. Tráelo al mundo. Ahora tiene una interfaz pública y probarlo ya no supone una crisis filosófica.
No debería probarse en absoluto. Son tres líneas de fontanería entre dos funciones públicas, ambas probadas, y ambas pegarían un grito en el cielo si la fontanería se rompiera. Déjala en paz. Cada test que escribes es una línea de código que debes mantener para siempre; gastar ese presupuesto en una función privada de dos líneas es el equivalente en testing a asegurar los cordones de tus zapatos.
Como es natural, siempre hay quien descubre que se puede acceder a
Module.function
por la puerta trasera mediante
apply/3
y un poco de deshonestidad con los atributos del módulo, o que basta con meter un
@compile :export_all
y seguir adelante. Por supuesto. También puedes arrancar la barandilla del balcón porque te tapa las vistas. La barandilla no era un fallo de diseño.
Hay un segundo regalo, más sutil, oculto aquí. Dado que el lenguaje hace que la implementación sea impracticable de probar, empuja discretamente al desarrollador perezoso —y todos somos el desarrollador perezoso los jueves por la tarde— a probar el comportamiento, que es lo único que merece la pena probar. Elixir ha codificado el buen gusto como una restricción del compilador. Pocos lenguajes tienen ese cuajo.
El comportamiento es una virtud, la implementación es un vicio
He aquí la razón mecánica por la que los tests de comportamiento detectan regresiones y los tests de implementación no.
Una regresión ocurre cuando alguien cambia la implementación y, accidentalmente, altera el comportamiento. Esa es toda la anatomía del problema. Ahora pregúntate qué le ocurre a cada tipo de test ante ese suceso.
El test de implementación se escribió contra la antigua implementación. El desarrollador cambió la implementación, por lo que el test falló; pero falló porque la implementación cambió, no porque haya nada necesariamente roto. El desarrollador, que es razonable, tiene prisa y ha visto a este test clamar falsas alarmas nueve veces este mes, actualiza el test para que coincida con la nueva implementación. El test se pone verde. El bug llega a producción. El test participó con entusiasmo en su propia derrota.
El test de comportamiento se escribió contra el contrato, que nadie pretendía cambiar. Falla, y no hay forma verosímil de «actualizarlo», porque actualizarlo significaría declarar abiertamente que el software ahora hace algo distinto. Eso exige una conversación, no un arreglo rápido. El bug no llega a producción.
Por esta razón, un auténtico test de regresión tiene un pedigrí muy particular. No lo escribe un desarrollador radiante durante el desarrollo de una funcionalidad. Lo escribe alguien de semblante sombrío tras un incidente, y se lee como una declaración judicial:
describe "issue #1472: timezone-aware expiry" do
test "a token minted at 23:59 UTC is not considered expired at 00:01 local" do
# Notificado el 2026-04-02 por un cliente en UTC+2 cuyo equipo
# entero vio cerrada su sesión cada noche durante nueve días.
token = mint_token(at: ~U[2026-04-02 23:59:00Z], ttl: {2, :hour})
assert {:ok, _claims} = verify(token, now: ~U[2026-04-03 00:01:00Z])
end
end
Observa lo que el test sabe y lo que ignora. Conoce el síntoma, la fecha y la víctima. Desconoce si la expiración se calcula con
DateTime.diff/3
, un desfase monotónico en caché o un reloj de sol. Podrás reescribir todo el subsistema de expiración mañana; este test te seguirá el ritmo sin rechistar, y el día que se ponga rojo, algo real se habrá roto.
Fíjate también en el comentario. Un test de regresión desprovisto del relato de su nacimiento es una mina antipersona para la siguiente persona, que tarde o temprano mirará esa aserción extraña, será incapaz de imaginar por qué alguien la escribió y la borrará. Todo test de regresión debería portar la esquela del error al que dio sepultura. La documentación más barata de tu repositorio es aquella que hace fallar la compilación en cuanto se vuelve falsa.
La regla, enunciada sin ambages: cada corrección de un error se acompaña de un test que falla antes del arreglo y pasa después de él. Si no eres capaz de escribir un test que falle, no has comprendido el error; solo lo has incomodado, y volverá.
Y entonces llegaron las máquinas
Todo lo anterior ha sido cierto desde aproximadamente 1975. Lo que ha cambiado es el volumen y la procedencia del código que desemboca en el repositorio.
El código generado no es peor que el código humano en el sentido en que claman los pesimistas. Es peor de una manera mucho más específica y peligrosa: es
localmente verosímil y globalmente desanclado
. Un modelo que produce una refactorización no recuerda el incidente de abril. Jamás le han lanzado una alerta al busca a las tres de la mañana. No sabe que el bucle de reintentos lleva un
+1
extraño porque la API de un proveedor empieza a contar desde uno, ni que el paso de normalización elimina un carácter Unicode concreto debido a un error en un cliente publicado hace cuatro años que todavía usan seiscientos clientes. Todo ese conocimiento reside exactamente en dos sitios: en la cabeza de personas que con el tiempo se marcharán, y en tu suite de regresión.
Cuando un ingeniero humano se topa con una línea de aspecto peculiar, titubea. Ejecuta
git blame
. Pregunta en el canal. Un modelo no titubea; no puede, porque titubear requiere saber lo que no sabes, y un amplificador estadístico es constitucionalmente incapaz de esa forma concreta de humildad. Ve una anomalía, la reconoce como una desviación del modismo con el que fue entrenado y la adecenta con la serena confianza del empleado de la limpieza que tira a la basura una instalación artística porque parecía un montón de escombros.
Tu suite de regresión es lo único en todo el edificio capaz de decirle que no a eso. No el linter, que considera la versión acicalada objetivamente más pulcra. No el verificador de tipos, que asiente al ver que los tipos encajan. No el revisor, que tiene ante sí un diff de cuatrocientas líneas y una reunión dentro de seis minutos. Solo el test escrito por alguien que estuvo allí en abril.
Esto invierte la economía de un modo que merece enunciarse con claridad. El coste de escribir código se ha derrumbado. El coste de verificar código no se ha movido un milímetro, porque verificar es donde reside el conocimiento del dominio, y el conocimiento del dominio jamás estuvo en las pulsaciones de teclado. Así que la proporción cambia. En 2015, un equipo que producía diez mil líneas al año podía permitirse una relación despreocupada con su suite de tests. Un equipo que ahora produce diez mil líneas al mes no puede; no porque el código sea peor, sino porque ningún ser humano lo está leyendo ya en su totalidad, y la suite ha sido ascendida silenciosamente de red de seguridad a lector principal.
Dos corolarios que a la gente le revienta escuchar:
Jamás permitas que el modelo escriba el test de regresión a partir del código corregido. La clave misma del test es que fue derivado del síntoma , con independencia de la implementación. Pásale al modelo una función parcheada y pídele tests, y obtendrás una descripción exquisitamente minuciosa del parche: otro espejo, solo que más rápido y mejor redactado. Escribe primero el test fallido, a partir del informe del fallo, con tus propias palabras. Luego deja que la máquina arregle el código hasta que el test se ponga verde. Esa dirección es colosalmente productiva. La otra dirección es mero teatro.
Desconfía profundamente de una suite en verde tras una gran refactorización generada.
O bien tu suite es genuinamente conductual, en cuyo caso enhorabuena y que aproveche el almuerzo; o bien tu suite es tan raquítica que jamás se habría percatado de nada. La forma de distinguirlas es romper algo a propósito y comprobar que la suite pegue un berrido. Si quieres hacer esto de manera sistemática en vez de por intuición, para eso están los tests de mutación: son una suite de tests para tu suite de tests, y la primera ejecución siempre resulta una lección de humildad. Prueba
muex
, por cierto; es una maravilla.
Más especímenes observados en libertad
Ya que la veda está abierta, repasemos algunos patrones adicionales que habitan en el lado correcto de la frontera, y algunos impostores que no.
Tests de caracterización para código que nadie entiende. Heredas cuarenta mil líneas sin tests y sin autor conocido. No puedes escribir tests de comportamiento, porque nadie conoce el comportamiento previsto. Así que anotas el comportamiento real : aliméntalo con entradas reales, registra las salidas reales y asegura que sigan siendo así. Los tests no afirman corrección; afirman estabilidad , que es lo único que honestamente puedes asegurar sobre un sistema que no comprendes. Esto es testing de regresión en su estado más puro, y es la puerta de entrada estándar para que un sistema heredado sea seguro de tocar. Etiqueta estos tests claramente, porque algunos de ellos conmemorarán fielmente errores existentes, y el día de mañana alguien arreglará uno y se quedará perplejo ante el rojo.
Doctests como contratos de comportamiento.
El
doctest
de Elixir es una idea discretamente radical: el ejemplo en tu documentación
es
el test. La documentación miente constantemente, en cada proyecto, en cada lenguaje; excepto aquí, donde una mentira rompe la compilación. Y como los ejemplos de documentación se escriben desde la perspectiva de quien llama por definición, son conductuales por construcción. No puedes documentar el acumulador intermedio de una función privada de forma que le resulte útil al usuario, así que no lo haces, y por ende no lo pruebas. El medio condiciona el mensaje.
Tests de contrato en las fronteras de los servicios. La regresión con más probabilidades de arruinarte el trimestre no está en tu código en absoluto; está en lo que cuelga al otro lado del cable, que un martes cualquiera cambió un campo de cadena a entero sin avisar a nadie. Un test de contrato apoyado en una interacción registrada y versionada detecta esto en tu ejecución de CI y no en producción. Comportamiento en la costura, que es exactamente donde el comportamiento resulta más difícil de razonar y más caro de errar.
Mox
y contratos explícitos, en contraposición a los mocks como sustantivo.
Falsear un colaborador privado para poder asegurar que fue llamado dos veces es probar la implementación con ceremonia extra y peores mensajes de error. Definir un behaviour, implementarlo dos veces —una para real, otra para tests— y verificar el
contrato de interacción
es probar el comportamiento con una trastienda intercambiable. Lo primero dificulta la refactorización; lo segundo la hace posible. La misma biblioteca, desenlaces opuestos, y la diferencia radica enteramente en si aquello que falseaste era un contrato o un accidente.
El test intermitente (
flaky
) es un test de regresión para tu concurrencia, y lo estás ignorando.
Todo equipo tiene ese test que falla en CI más o menos una vez cada quince días, y todo equipo le ha plantado un
@tag :skip
o un envoltorio de reintentos. Ese test no está roto. Ese test es el único miembro de tu suite que ha reparado en la condición de carrera, y le has puesto una mordaza. La falta de determinismo en los tests es casi siempre un positivo verídico sobre la falta de determinismo en el sistema.
Hora, configuración regional y codificación: los tres jinetes.
Una proporción pasmosa de todas las regresiones jamás registradas proviene de una fecha que cruza una frontera, una configuración regional que formatea un número de forma distinta o una cadena que contiene un carácter cuya existencia el autor ni sospechaba. Son conductuales por naturaleza y casi nunca quedan cubiertas por tests unitarios hechos a mano, porque la imaginación del autor está acotada por su zona horaria, su región y su abecedario. Los generadores basados en propiedades no padecen esas limitaciones, razón por la cual
StreamData
da con el emoji en el campo de usuario en unas nueve iteraciones.
Archivos dorados (
golden files
), usados como es debido.
El testing por instantáneas (
snapshots
) goza de mala reputación, ganada a pulso por equipos que ejecutan «actualizar todas las capturas» como un acto reflejo y comitean el resultado sin leerlo. Un archivo dorado revisado con la misma seriedad que el código fuente es un test de regresión excelente para cualquier cosa con una forma de salida compleja: plantillas renderizadas, esquemas generados, cargas útiles serializadas. Un archivo dorado actualizado por memoria muscular es un
git add .
con pasos extra.
Presupuestos de rendimiento.
Una función que devuelve la respuesta correcta en nueve segundos, habiendo tardado previamente cuarenta milisegundos, ha sufrido una regresión: el comportamiento de un sistema incluye cuánto tarda en comportarse. Una aserción tosca sobre un límite superior, o una prueba de rendimiento en CI, caza ese
Enum.map
accidental sobre una consulta de base de datos que alguien coló dentro de un bucle. Nadie escribe estos tests hasta el primer apagón, lo cual es una lástima, porque son baratísimos.
El test que eliminas. Lo último y más herético: un test que jamás ha fallado por un motivo de peso en tres años no te está protegiendo. Es una partida en tu presupuesto de mantenimiento, un lastre en tu tiempo de CI y un pequeño peaje diario a la atención de todo el mundo. Las suites de regresión deben crecer por sedimentación de incidentes reales, no por una cuota de cobertura impuesta desde arriba. La cobertura mide qué líneas se ejecutaron, no qué comportamientos se verificaron; una suite que llame a cada función sin hacer aserciones obtiene un cien perfecto, al igual que una que lo asevere todo sin comprender nada.
La versión resumida
Los tests son baratos y abundantes; los tests de regresión son caros y escasos, porque cada uno cuesta una avería real para ser adquirido. Trátalos en consecuencia. Escríbelos a partir del informe de error y no a partir de la solución. Apúntalos hacia el contrato y no hacia la fontanería. Deja que el compilador te impida probar funciones privadas y agradécele en silencio la disciplina. Prefiere la ley al ejemplo, y deja que el generador encuentre el contraejemplo en el que jamás habrías pensado.
Y ahora que una proporción creciente de tu código llega desde una fuente sin memoria de los últimos cinco años, comprende en qué se ha convertido tu suite. Ya no es una simple puerta de control de calidad. Es la única memoria institucional que tienes que no duerme, no se marcha y no puede ser persuadida de abandonar su postura mediante un párrafo persuasivo de razonamientos plausibles.
Sé agresivo con ella. Las regresiones, desde luego, lo serán.
Anteriormente, sobre el arte de no engañarse a uno mismo con sus propias herramientas: