🧠 ¿Qué son las pruebas unitarias?

Las pruebas unitarias son una técnica de verificación que permite comprobar si funciones, métodos o clases individuales de un software funcionan correctamente de forma aislada.

Es decir, en vez de probar toda la aplicación, nos enfocamos en pequeñas piezas del código para detectar errores lo antes posible.

Una «unidad» puede ser:

• Una función pura (calcular_total())
• Un método de una clase (Usuario.validar_email())
• Un componente que no depende de sistemas externos

🧪 El objetivo es validar que una unidad del código hace exactamente lo que debe hacer, ni más ni menos.

⚙️ ¿Por qué son importantes?

Las pruebas unitarias son un pilar esencial del desarrollo profesional:

• ✅ Previenen regresiones: Si algo se rompe, lo sabrás antes de subir a producción.
• 🔁 Facilitan cambios: Puedes refactorizar sin miedo.
• 🧼 Documentan comportamiento: Un test describe lo que se espera que haga una función.
• 🚀 Permiten TDD (Desarrollo guiado por pruebas): escribes el test antes del código.

📌 ¿Cuándo hacer pruebas unitarias?

Idealmente:

• Durante el desarrollo de nuevas funciones
• Al hacer refactorizaciones
• Antes de un pull request
• Como parte de una integración continua (CI)

🛠️ Herramientas más usadas en Python

1. unittest (estándar en Python)
2. pytest (más moderno y potente, recomendado en 2025)
3. nose2, doctest y hypothesis (para casos más específicos)

🧪 Ejemplo básico con unittest

python
# calculadora.py
def sumar(a, b):
    return a + b

python
# test_calculadora.py
import unittest
from calculadora import sumar

class TestCalculadora(unittest.TestCase):
    def test_sumar_enteros(self):
        self.assertEqual(sumar(2, 3), 5)

    def test_sumar_negativos(self):
        self.assertEqual(sumar(-1, -1), -2)

if __name__ == '__main__':
    unittest.main()

📌 Resultado:

bash
$ python test_calculadora.py
..
----------------------------------------------------------------------
Ran 2 tests in 0.000s

OK

✅ Buenas prácticas al escribir pruebas unitarias

• Nombre descriptivo del test (test_validar_email_correcto)
• Un único propósito por prueba
• Evita dependencias externas (bases de datos, API, etc.)
• Usa mocks o stubs si necesitas simular servicios externos
• Mantén los tests actualizados cuando cambie el código
• Inclúyelos en tu CI/CD

⚡️ Escribiendo tests más expresivos con pytest

python
# test_calculadora_pytest.py
from calculadora import sumar

def test_sumar_positivos():
    assert sumar(10, 5) == 15

def test_sumar_flotantes():
    assert sumar(2.5, 3.0) == 5.5

✅ Ventajas de pytest:

• No requiere clases
• Mensajes de error más claros
• Plugins como pytest-cov para ver cobertura

📊 ¿Cómo medir la cobertura de tus tests?

Instala el paquete:

bash
pip install pytest-cov

Ejecuta los tests con reporte:

bash
pytest --cov=calculadora test_calculadora_pytest.py

🔍 Esto te dirá qué porcentaje de tu código está cubierto por pruebas. Apunta a +80%, pero no persigas el 100% si no aporta valor.

🔁 TDD y pruebas unitarias

En Desarrollo guiado por pruebas (TDD) el flujo es:

1. Escribes un test que falla (porque el código aún no existe)
2. Escribes el código mínimo para que pase
3. Refactorizas el código manteniendo el test verde

Esto asegura que:

• Sólo escribes código necesario
• Todo está cubierto por tests
• Refactorizas con seguridad

🧩 Integración en un proyecto real

Caso: Estás construyendo una app de gastos personales. Necesitas una función para calcular el total mensual.

python
def total_gastos(lista_gastos):
    return sum(lista_gastos)

Test:

python
def test_total_gastos_basico():
    assert total_gastos([100, 200, 50]) == 350

def test_total_gastos_vacio():
    assert total_gastos([]) == 0

Si mañana cambias el cálculo (por error o mejora), estos tests te protegerán contra resultados inesperados.

📉 ¿Qué pasa si no haces pruebas unitarias?

• Bugs silenciosos en producción
• Refactorizaciones que rompen cosas sin avisar
• Código acoplado y difícil de mantener
• Mayor coste técnico a medio/largo plazo

✅ Ejemplo real: Pruebas unitarias en una startup edtech

Una startup de educación online lanza una API para recomendar cursos personalizados.
La lógica de recomendación se basa en puntuaciones de usuario, historial de navegación y temáticas favoritas.

Los desarrolladores implementan pruebas unitarias para validar:

• Si un curso con score alto y afinidad aparece primero
• Si cursos con baja puntuación son descartados
• Que no se recomienden cursos ya completados

Cuando un nuevo dev añade un nuevo filtro, una prueba unitaria falla: está excluyendo cursos válidos.
Gracias a los tests, detectan el error antes de que el sistema llegue a producción y puedan perder clientes.

🎯 Este es el poder real de las pruebas unitarias: confianza continua.

🧠 Conclusión

Las pruebas unitarias no son solo una técnica: son un hábito profesional.
Te ayudan a escribir mejor código, más mantenible y más seguro para tus usuarios.

Si usas Python, empieza con pytest, automatiza con GitHub Actions o GitLab CI, y conviértelo en parte de tu flujo de desarrollo.