Testing y Aseguramiento de Calidad

El Test que No Escribiste

🔄 Repaso rápido: En la lección anterior, exploramos debugging y resolución de errores con IA. Ahora construyamos sobre esa base para asegurar que el código siga funcionando.

Un escenario que todo developer ha vivido: escribes una función, la testeas manualmente con un par de inputs, funciona, la shipeas. Tres semanas después, un usuario encuentra un bug. ¿El input? Un string vacío. O un número negativo. O una lista con un solo elemento en vez de muchos.

Sabías que debiste haber testeado esos casos. Solo… no lo hiciste.

La IA no se olvida de edge cases. No se aburre escribiendo el quinceavo test. Y no se salta los inputs raros porque “eso nunca va a pasar en producción.” Pongamos eso a trabajar.

El Flujo de Testing con IA

Aquí va el flujo que usarás para cada sesión de testing:

1. Proporciona el código bajo prueba con sus dependencias
2. Describe el comportamiento esperado (no solo lo que el código hace — lo que debería hacer)
3. Solicita tipos de test específicos (unit, integration, edge cases)
4. Revisa y refina los tests generados
5. Agrega tests manuales para casos de dominio que la IA pueda perder

Paso 1: Dale a la IA la Imagen Completa

Digamos que tienes esta función:

def calculate_discount(
    subtotal: float,
    coupon_code: str | None,
    is_member: bool,
    items_count: int
) -> dict:
    """Calcula descuento del pedido basado en múltiples factores."""
    discount = 0.0
    reasons = []

    # Descuento de miembro: 10%
    if is_member:
        discount += subtotal * 0.10
        reasons.append("Descuento miembro: 10%")

    # Descuento por volumen: 5% para 10+ artículos
    if items_count >= 10:
        discount += subtotal * 0.05
        reasons.append("Descuento volumen: 5%")

    # Códigos de cupón
    if coupon_code:
        coupon_discounts = {"SAVE20": 0.20, "WELCOME10": 0.10, "VIP30": 0.30}
        rate = coupon_discounts.get(coupon_code.upper())
        if rate:
            discount += subtotal * rate
            reasons.append(f"Cupón {coupon_code}: {int(rate*100)}%")

    # Tope al 50%
    max_discount = subtotal * 0.50
    if discount > max_discount:
        discount = max_discount
        reasons.append("Tope de 50% máximo")

    return {
        "subtotal": subtotal,
        "discount": round(discount, 2),
        "total": round(subtotal - discount, 2),
        "reasons": reasons,
    }

Así le pedirías a la IA:

Escribe una suite de tests completa para esta función
calculate_discount usando pytest. Incluye:

1. Happy path para cada tipo de descuento
2. Tests de combinación (miembro + cupón, miembro + volumen,
   los tres juntos)
3. Edge cases (subtotal cero, negativo, cupón string vacío,
   cupón inválido, sensibilidad a mayúsculas)
4. Tests de frontera (exactamente 10 artículos, 9 artículos
   para el umbral de volumen)
5. Comportamiento del tope al 50%
6. Edge cases de tipo (None vs string vacío para cupón)

Usa nombres de test descriptivos que expliquen el escenario.
Sigue el patrón AAA (Arrange, Act, Assert).

✅ Revisión Rápida: ¿Cuáles son los cinco pasos del flujo de testing con IA?

Paso 2: Revisa los Tests Generados

No confíes ciegamente en tests generados por IA. Busca estos problemas:

Tests tautológicos — testean que el código hace lo que el código hace, sin verificar que haga lo correcto:

# MAL: Solo reimplementa la lógica de la función
def test_discount_calculation(self):
    subtotal = 100.0
    expected = subtotal * 0.10  # Copiando la lógica del fuente
    result = calculate_discount(subtotal, None, True, 1)
    assert result["discount"] == expected

Edge cases faltantes que la IA quizás no piensa:

# ¿La IA testeó esto?
def test_subtotal_negativo(self):
    # ¿Debería permitirse? ¿Cuál es el comportamiento esperado?
    result = calculate_discount(-50.0, None, True, 1)

def test_precision_punto_flotante(self):
    result = calculate_discount(33.33, "SAVE20", True, 1)
    # 33.33 * 0.30 = 9.999... ¿Funciona correctamente el redondeo?

Assertions incorrectos — donde el valor esperado de la IA está mal. Corre cada test y verifica que las fallas sean bugs reales, no expectativas equivocadas.

Generando Tests de Integración

Los unit tests cubren funciones individuales. Los tests de integración cubren cómo las piezas trabajan juntas. La IA es genial generando ambos — solo necesitas dar más contexto:

Escribe tests de integración para nuestro flujo de checkout.
Así se conectan las piezas:

1. CartService.getItems() retorna los artículos del carrito
2. DiscountService.calculate() aplica descuentos
3. PaymentService.charge() procesa el pago
4. OrderService.create() crea el registro del pedido

Testea estos escenarios:
- Checkout exitoso con descuento
- Falla de pago no debe crear un pedido
- Carrito vacío debe rechazar temprano
- Cupón expirado durante checkout

Interfaces de cada servicio:
[pega las interfaces relevantes]

Usa pytest con unittest.mock para mockear servicios.

La Pirámide de Tests con IA

La IA cambia cómo abordas la pirámide de tests:

Unit tests: Deja que la IA genere el 80%+ de estos. Los edge cases que la IA detecta valen oro. Revisa y complementa con casos específicos de dominio.

Tests de integración: Co-crea con la IA. Tú defines los escenarios e interacciones; la IA escribe el código de test y setup de mocks.

Tests E2E: Tú diseñas los flujos de usuario; la IA ayuda a traducirlos a código de test (Playwright, Cypress, etc.).

Pidiendo a la IA que Encuentre Qué NO Está Testeado

Uno de los prompts de testing más poderosos:

Aquí va mi función y su suite de tests actual.
¿Qué comportamientos, edge cases o condiciones de error
NO están testeados actualmente?

[pega función]
[pega tests existentes]

La IA identificará gaps como:

• “No hay test para cuando items_count es 0”
• “No hay test verificando el orden del array reasons”
• “No hay test para cálculos de descuento concurrentes”
• “No hay test para subtotales extremadamente grandes (¿overflow?)”

Es como tener un QA senior revisando tu cobertura de tests.

Ejercicio Práctico

Toma una función que hayas escrito recientemente y prueba este flujo:

1. Pégala en tu asistente de IA
2. Pide tests completos incluyendo edge cases
3. Revisa cada test generado — ¿testean comportamiento o solo implementación?
4. Corre los tests — ¿todos pasan? Si no, ¿es un bug en el código o en el test?
5. Pregunta a la IA: “¿Qué NO está testeado?” y agrega esos casos

Probablemente descubrirás al menos un edge case que no habías considerado.

Conclusiones Clave

• La IA destaca identificando edge cases y condiciones de frontera que los humanos se pierden
• Proporciona la función, sus dependencias y comportamientos esperados para mejores resultados
• Revisa tests generados buscando assertions tautológicos y valores esperados incorrectos
• Usa la IA para encontrar gaps en la cobertura de tests existente
• Deja que la IA maneje la mayor parte de unit tests; co-crea integration y E2E tests
• Siempre corre los tests generados y verifica que las fallas indiquen bugs reales

Siguiente

En la Lección 5: Revisión de Código y Refactoring, aprenderás a usar la IA como un revisor incansable que detecta issues antes de que lleguen a producción.