La Guía Inicial de Testing de Software

Cualquier aplicación que exista necesita ser probada antes de ir a producción, esto es mucho mejor que apretar el botón de deploy y que el WhatsApp empiece a cantar la quinta sinfonía del caos en instantes. El cliente x no logra terminar la tarea y, la herramienta z se cayó... Claro, no se puede adivinar el futuro, pero se puede hacer algo muy cercano a eso.
Hacer tests es una tarea aburrida, monótona, pero absurdamente necesaria e importante. Ese jueguito que simula el mundial para presumir con los amigos no va a necesitar ningún test, pero si hay un cliente que paga al final de la ecuación, tiene que haber tests: es el certificado digital de seguridad y calidad de tu proyecto.
Conoce un poco de la historia de los tests más abajo, o salta directo a para qué sirve cada uno. Este es un texto introductorio para conocer los tests; en un post futuro, puedo hablar sobre tests de performance, carga, seguridad, usabilidad, regresión, aceptación, CI/CD, cobertura y otras cosas.
¿Quiénes Son, Dónde Viven, Qué Comen?
No vamos a hablar de los años 50-70, en esa época el proyecto prácticamente se hacía en el hardware, y los tests eran algo impensable. Pero hacia los años 90, Kent Beck creó SUnit (que se convirtió en los tests unit que conocemos hoy). Por primera vez en la historia los desarrolladores pudieron tener un estándar para escribir código que servía para probar otro código. Esto creó el término TDD (Test-Driven Development), que traía la idea de que el test no es el fin, sino parte del proceso, formando parte de la arquitectura.
Después de los años 2000, a medida que el hardware y la capacidad de software fueron avanzando y escalando, ejecutar tests manuales en grandes proyectos empezó a volverse insostenible, y de ahí vino el término Pirámide de Tests, con el orden y la necesidad de cada uno.
Hoy, lo que tenemos se llama Shift-left: una cinta de tests, uno tras otro, con análisis estático, compilador, etc.
Todos los Tipos de Tests
Análisis Estático
Esta es la primera capa, antes de correr cualquier test previo a este, el análisis estático hace una inspección completa de tu código buscando fallas lógicas y rupturas de contrato. JavaScript tiene ESLint, TypeScript tiene el compilador de TS, PHP tiene PHPStan, Go tiene go vet y staticcheck, Rust tiene su propio compilador con Borrow Checker.
Tests Unitarios
Los más usados, por lejos. Con los tests unitarios vas a probar la unidad lógica más pequeña de forma aislada, puede ser - por ejemplo - una función o clase. No tiene contacto con APIs externas ni nada de producción, lo que se usa son mock-datas, información falsa que va a validar reglas de negocio.
Cálculos de envío, reglas de descuento, manejo de servicios, son validaciones extremadamente rápidas que usan tests unitarios.
Curiosidad: PHP tiene PHPUnit o Pest, JS/TS tiene Vitest o Jest. Go y Rust, en cambio, tratan los tests como ciudadanos de primera clase, no necesitan ningún framework externo, ambos poseen nativamente una estructura completa de tests.
Tests de Integración
A diferencia de los tests unitarios, los tests de integración se van a comunicar con bases de datos reales, colas, cache o sistemas de archivos. Aquí el objetivo es garantizar - por ejemplo - que el repo guarda correctamente en PostgreSQL, o que el mensaje llega a RabbitMQ.
¡Ah! ¿entonces van a probar directo en mi proyecto en producción?? ¡Calma! No. Lo más común es probar en un contenedor Docker descartable y aislado (conocido como TestContainer), en el que se generan seeds, o en un ambiente exclusivo para tests.
Tests e2e (End to End)
En esta capa, el objetivo es simular al usuario real. Los tests e2e aplican 30, 40, 50 o más operaciones diferentes y validan el flujo crítico. Se pueden hacer, por ejemplo, diversas situaciones en las que el cliente accede al sitio y hace varias operaciones, incluyendo si logra iniciar sesión, agregar un producto al carrito de compras, pasar la tarjeta de crédito, calcular el envío, etc.
Recuerda que usé calcular el envío como test unitario, pero aquí es diferente, el test e2e va a simular al usuario accediendo a la página y calculando el envío directamente desde ahí. Estos tests son mis preferidos.
Smoke Tests
Después del deploy se verifica que todo esté en orden. Entonces un script simple puede hacer ping a algunas rutas y verificar que devuelvan 200. Si devuelve 500, ocurre un rollback automático y el equipo de desarrollo corre para entender qué pasó.
Curiosidad: los smoke tests vienen de una broma famosa de la ingeniería de hardware, que es más o menos así, en español: "¿lo enchufaste, salió humo?"
Estos tests fueron hechos para ser simples y rápidos. Aunque no lo parezca, son una verificación extra importante pues va a verificar cómo está el proyecto en el hardware real, en producción.
Mutation Tests
Ok, este lo usa poca gente. ¡Yo mismo nunca lo usé! Pero conocerlo no le hace mal a nadie. El mutation test es el control interno, cuando está escrito en la pared "Who tests the tests??", aparece y dice en voz alta: "¡YO!"
Para saber si los tests realmente funcionan y la cobertura no es falsa, los tests de mutación insertan bugs a propósito en el proyecto, como cambiar un simple + por un - o invertir un boolean. Después de hacer la maldad, corre los tests y espera que fallen, si pasan, se enciende la alerta roja extrema: los tests están ciegos, y necesitan ser revisados urgentemente.
Depende de Cada Caso
Escribir tests sí aumenta el tiempo de desarrollo, pero reduce mucho el dolor de cabeza después (créeme, saltarse los tests es pedirlo). ¿Quieres evitar hotfixes, retrabajo y problemas en producción con personas reales? Solo los tests pueden minimizar eso.
Sí, son aburridos, pero son cruciales.