Pruebas de Caja Negra: Técnicas y Enfoques

# Entrada: La edad debe estar entre 18-65 para elegibilidad

# Clases de equivalencia:
# Inválida: edad < 18
# Válida: 18 ≤ edad ≤ 65
# Inválida: edad > 65

# Casos de prueba (uno de cada partición):
test_cases = [
    (15, False),  # Debajo del mínimo
    (30, True),   # Rango válido
    (70, False)   # Arriba del máximo
]

def test_age_eligibility():
    for age, expected in test_cases:
        result = check_eligibility(age)
        assert result == expected, f"Falló para edad {age}"

# Requisito: La contraseña debe tener 8-20 caracteres

# Valores de prueba:
boundary_tests = [
    ("1234567", False),      # Longitud 7 (justo debajo del mínimo)
    ("12345678", True),       # Longitud 8 (límite mínimo)
    ("123456789", True),      # Longitud 9 (justo arriba del mínimo)
    ("12345678901234567890", True),  # Longitud 20 (límite máximo)
    ("123456789012345678901", False) # Longitud 21 (justo arriba del máximo)
]

def test_password_length():
    for password, expected in boundary_tests:
        result = validate_password(password)
        assert result == expected, f"Falló para longitud {len(password)}"

def test_loan_approval():
    test_scenarios = [
        # (puntaje_credito, ingreso, empleo, esperado)
        (750, "alto", "estable", True),
        (750, "bajo", "estable", True),
        (750, "alto", "inestable", True),
        (750, "bajo", "inestable", False),
        (650, "alto", "estable", False),
        (650, "bajo", "estable", False),
        (650, "alto", "inestable", False),
        (650, "bajo", "inestable", False),
    ]

    for score, ingreso, empleo, esperado in test_scenarios:
        result = approve_loan(score, ingreso, empleo)
        assert result == esperado

class OrderState:
    NEW = "nuevo"
    PAID = "pagado"
    SHIPPED = "enviado"
    DELIVERED = "entregado"
    COMPLETED = "completado"
    CANCELLED = "cancelado"

def test_order_state_transitions():
    # Transiciones válidas
    assert process_payment("nuevo") == "pagado"
    assert ship_order("pagado") == "enviado"
    assert deliver_order("enviado") == "entregado"
    assert complete_order("entregado") == "completado"

    # Transiciones inválidas
    with pytest.raises(InvalidTransition):
        ship_order("nuevo")  # No se puede enviar pedido sin pagar

    # Cancelación desde cualquier estado
    for state in [OrderState.NEW, OrderState.PAID, OrderState.SHIPPED]:
        assert cancel_order(state) == OrderState.CANCELLED

Característica: Inicio de sesión de usuario

  Escenario: Inicio de sesión exitoso con credenciales válidas
    Dado que el usuario está en la página de inicio de sesión
    Cuando el usuario ingresa usuario válido "juan@ejemplo.com"
    Y el usuario ingresa contraseña válida "ContraseñaSegura123"
    Y el usuario hace clic en el botón de inicio de sesión
    Entonces el usuario debe ser redirigido al panel de control
    Y debe mostrarse el mensaje de bienvenida "Bienvenido, Juan"

  Escenario: Inicio de sesión fallido con contraseña inválida
    Dado que el usuario está en la página de inicio de sesión
    Cuando el usuario ingresa usuario válido "juan@ejemplo.com"
    Y el usuario ingresa contraseña inválida "ContraseñaIncorrecta"
    Y el usuario hace clic en el botón de inicio de sesión
    Entonces debe mostrarse el mensaje de error "Credenciales inválidas"
    Y el usuario debe permanecer en la página de inicio de sesión

  Escenario: Bloqueo de cuenta después de intentos fallidos
    Dado que el usuario ha fallado el inicio de sesión 2 veces
    Cuando el usuario ingresa credenciales inválidas nuevamente
    Entonces la cuenta debe bloquearse
    Y debe mostrarse el mensaje de error "Cuenta bloqueada"

# Parámetros:
# Navegador: Chrome, Firefox, Safari
# SO: Windows, macOS, Linux
# Resolución: 1920x1080, 1366x768

# Combinación completa: 3 × 3 × 2 = 18 pruebas
# Reducción all-pairs: ~9 pruebas

pairwise_combinations = [
    ("Chrome", "Windows", "1920x1080"),
    ("Chrome", "macOS", "1366x768"),
    ("Chrome", "Linux", "1920x1080"),
    ("Firefox", "Windows", "1366x768"),
    ("Firefox", "macOS", "1920x1080"),
    ("Firefox", "Linux", "1366x768"),
    ("Safari", "Windows", "1920x1080"),
    ("Safari", "macOS", "1366x768"),
    ("Safari", "Linux", "1920x1080"),
]

def test_browser_compatibility():
    for navegador, so, resolucion in pairwise_combinations:
        launch_browser(navegador, so, resolucion)
        assert page_loads_correctly()
        assert elements_render_properly()

# Entradas típicas propensas a errores para probar
error_prone_tests = [
    # Caracteres especiales
    test_input("'; DROP TABLE users--"),  # Inyección SQL
    test_input("<script>alert('XSS')</script>"),  # XSS

    # Casos límite
    test_input(""),  # Entrada vacía
    test_input(" " * 1000),  # Entrada muy larga
    test_input("null"),  # Valores nulos

    # Problemas de formato
    test_input("0000-00-00"),  # Fecha inválida
    test_input("999-999-9999"),  # Teléfono inválido
    test_input("noesunemail"),  # Email inválido
]

Historia de Usuario: Como cliente, quiero buscar productos por nombre
Criterios de Aceptación:
  - La búsqueda devuelve resultados que contienen el término buscado
  - La búsqueda no distingue mayúsculas/minúsculas
  - Los resultados se muestran en 2 segundos
  - Máximo 20 resultados por página
  - La búsqueda vacía devuelve todos los productos

Casos de Prueba:
  - TC001: Búsqueda con nombre exacto del producto
  - TC002: Búsqueda con nombre parcial
  - TC003: Búsqueda con mayúsculas/minúsculas mezcladas
  - TC004: Verificar tiempo de respuesta < 2s
  - TC005: Verificar paginación a 20 artículos
  - TC006: Verificar comportamiento de búsqueda vacía

def test_registration_form():
    # Partición de Equivalencia + AVL
    test_email_formats()
    test_password_strength()

    # Tabla de Decisión
    test_field_combinations()

    # Transición de Estado
    test_form_submission_states()

    # Adivinación de Errores
    test_special_characters()
    test_sql_injection_attempts()

# Alta Prioridad
@pytest.mark.priority("alta")
def test_payment_processing():
    """Ruta crítica - impacto en ingresos"""
    pass

# Prioridad Media
@pytest.mark.priority("media")
def test_search_functionality() (como se discute en [Bug Anatomy: From Discovery to Resolution](/blog/bug-anatomy)):
    """Usado frecuentemente - experiencia de usuario"""
    pass

# Baja Prioridad
@pytest.mark.priority("baja")
def test_footer_links():
    """Bajo riesgo - impacto mínimo"""
    pass

def test_user_registration_with_valid_data():
    """
    ID de Prueba: TC_REG_001
    Descripción: Verificar que el usuario puede registrarse con datos válidos

    Precondiciones:
    - La aplicación es accesible
    - El email no está ya registrado

    Pasos de Prueba:
    1. Navegar a la página de registro
    2. Ingresar email válido
    3. Ingresar contraseña válida (8+ caracteres)
    4. Hacer clic en el botón Registrar

    Resultado Esperado:
    - El registro tiene éxito
    - Usuario redirigido al panel de control
    - Email de bienvenida enviado

    Datos de Prueba:
    - Email: nuevousuario@ejemplo.com
    - Contraseña: ContraseñaVálida123
    """
    # Implementación de la prueba
    pass

class TestCheckoutFlow:
    """Suite completa de pruebas de caja negra para checkout"""

    def test_guest_checkout_valid_card(self):
        """Ruta feliz - usuario invitado, pago válido"""
        # Agregar artículos al carrito
        add_to_cart("Producto A", quantity=2)
        add_to_cart("Producto B", quantity=1)

        # Proceder al checkout
        goto_checkout()

        # Ingresar información de envío
        fill_shipping({
            "name": "Juan Pérez",
            "address": "Calle Principal 123",
            "city": "Madrid",
            "zip": "28001"
        })

        # Ingresar pago
        fill_payment({
            "card_number": "4111111111111111",
            "expiry": "12/25",
            "cvv": "123"
        })

        # Enviar pedido
        submit_order()

        # Verificar
        assert order_confirmed()
        assert confirmation_email_sent()
        assert inventory_updated()

    def test_checkout_with_invalid_card(self):
        """Ruta de error - método de pago inválido"""
        add_to_cart("Producto A")
        goto_checkout()
        fill_shipping(valid_shipping_data())

        fill_payment({
            "card_number": "4111111111111112",  # Inválida
            "expiry": "12/25",
            "cvv": "123"
        })

        submit_order()

        # Verificar manejo de errores
        assert error_displayed("Pago rechazado")
        assert order_not_created()
        assert cart_preserved()

    def test_checkout_with_expired_coupon(self):
        """Caso extremo - código promocional vencido"""
        add_to_cart("Producto A")
        goto_checkout()
        apply_coupon("VENCIDO2024")

        assert error_displayed("Cupón vencido")
        assert discount_not_applied()

    def test_checkout_performance(self):
        """No funcional - tiempo de respuesta"""
        start = time.time()
        complete_checkout_flow()
        duration = time.time() - start

        assert duration < 5.0, "El checkout tomó demasiado tiempo"