Niveles de Testing: Unit, Integration, System y UAT

# Ejemplo: Unit test para servicio de autenticación
import pytest
from auth_service import AuthService, InvalidCredentialsError

class TestAuthService:
    def setup_method(self):
        """Configurar fixtures antes de cada test"""
        self.auth = AuthService(database="test_db")
 (como se discute en [Entry and Exit Criteria in Software Testing: When to Start and Stop Testing](/blog/entry-exit-criteria))        self.valid_user = {
            "email": "test@example.com",
            "password": "SecurePass123!"
        }

    def test_successful_authentication(self):
        """Test de que credenciales válidas retornan auth token"""
        token = self.auth.authenticate(
            self.valid_user["email"],
            self.valid_user["password"]
        )

        assert token is not None
        assert len(token) == 64  # Longitud de JWT token
        assert self.auth.is_token_valid(token) is True

    def test_invalid_password_raises_error(self):
        """Test de que contraseña inválida genera error apropiado"""
        with pytest.raises(InvalidCredentialsError) as exc_info:
            self.auth.authenticate(
                self.valid_user["email"],
                "WrongPassword"
            )

        assert "Invalid credentials" in str(exc_info.value)

    def test_nonexistent_user_raises_error(self):
        """Test de que usuario no existente genera error"""
        with pytest.raises(InvalidCredentialsError):
            self.auth.authenticate(
                "nonexistent@example.com",
                "anypassword"
            )

    def test_account_lockout_after_failed_attempts(self):
        """Test de que cuenta se bloquea después de 5 intentos fallidos"""
        # Intentar 5 logins fallidos
        for _ in range(5):
            with pytest.raises(InvalidCredentialsError):
                self.auth.authenticate(
                    self.valid_user["email"],
                    "WrongPassword"
                )

        # 6to intento debe generar AccountLockedError
        from auth_service import AccountLockedError
        with pytest.raises(AccountLockedError):
            self.auth.authenticate(
                self.valid_user["email"],
                self.valid_user["password"]  # Incluso con contraseña correcta
            )

    def test_token_expiration(self):
        """Test de que tokens expiran después de tiempo configurado"""
        import time

        token = self.auth.authenticate(
            self.valid_user["email"],
            self.valid_user["password"]
        )

        # Simular paso de tiempo (en código real, usar librería de time mocking)
        self.auth._set_time_offset(3600)  # +1 hora

        assert self.auth.is_token_valid(token) is False

// Ejemplo: Testing de integración entre autenticación y servicio de usuario
const request = require('supertest');
const app = require('../app');

describe('Integración de Autenticación y Servicio de Usuario', () => {
  let authToken;
  let userId;

  beforeAll(async () => {
    // Configurar base de datos de prueba
    await setupTestDatabase() (como se discute en [Grey Box Testing: Best of Both Worlds](/blog/grey-box-testing));
  });

  afterAll(async () => {
    // Limpiar base de datos de prueba
    await cleanupTestDatabase();
  });

  test('Registro de usuario crea usuario y retorna auth token', async () => {
    const newUser = {
      email: 'integration@test.com',
      password: 'SecurePass123!',
      name: 'Integration Test User'
    };

    const response = await request(app)
      .post('/api/auth/register')
      .send(newUser)
      .expect(201);

    // Verificar estructura de respuesta
    expect(response.body).toHaveProperty('token');
    expect(response.body).toHaveProperty('user');
    expect(response.body.user.email).toBe(newUser.email);

    // Guardar para tests subsecuentes
    authToken = response.body.token;
    userId = response.body.user.id;
  });

  test('Usuario autenticado puede acceder endpoint de perfil', async () => {
    const response = await request(app)
      .get(`/api/users/${userId}/profile`)
      .set('Authorization', `Bearer ${authToken}`)
      .expect(200);

    expect(response.body.email).toBe('integration@test.com');
    expect(response.body.name).toBe('Integration Test User');
  });

  test('Solicitud no autenticada a perfil retorna 401', async () => {
    await request(app)
      .get(`/api/users/${userId}/profile`)
      .expect(401);
  });

  test('Token inválido retorna 403', async () => {
    await request(app)
      .get(`/api/users/${userId}/profile`)
      .set('Authorization', 'Bearer invalid_token_here')
      .expect(403);
  });

  test('Usuario puede actualizar perfil con auth token válido', async () => {
    const updates = {
      name: 'Updated Name',
      bio: 'Integration testing is awesome'
    };

    const response = await request(app)
      .patch(`/api/users/${userId}/profile`)
      .set('Authorization', `Bearer ${authToken}`)
      .send(updates)
      .expect(200);

    expect(response.body.name).toBe('Updated Name');
    expect(response.body.bio).toBe('Integration testing is awesome');
  });

  test('Logout invalida auth token', async () => {
    // Logout
    await request(app)
      .post('/api/auth/logout')
      .set('Authorization', `Bearer ${authToken}`)
      .expect(200);

    // Intentar acceder a perfil con token invalidado
    await request(app)
      .get(`/api/users/${userId}/profile`)
      .set('Authorization', `Bearer ${authToken}`)
      .expect(401);
  });
});

# System Test Funcional: Flujo de Compra E-commerce

Feature: Flujo completo de compra
  Como cliente
  Quiero comprar productos
  Para que pueda recibirlos en mi dirección

Background:
  Given el sistema e-commerce está funcionando
  And existen productos de prueba en inventario
  And existe cuenta de usuario de prueba "systemtest@example.com"

Scenario: Compra exitosa de producto con tarjeta de crédito
  Given estoy autenticado como "systemtest@example.com"
  When busco "wireless headphones"
  And selecciono "Sony WH-1000XM4" de resultados
  And hago clic en "Agregar al Carrito"
  And procedo al checkout
  And ingreso dirección de envío:
    | Campo      | Valor              |
    | Calle      | 123 Test St        |
    | Ciudad     | San Francisco      |
    | Estado     | CA                 |
    | Código     | 94105              |
  And selecciono "Tarjeta de Crédito" como método de pago
  And ingreso detalles válidos de tarjeta de crédito
  And confirmo la orden
  Then debo ver mensaje "Orden Confirmada"
  And debo recibir email de confirmación de orden en menos de 2 minutos
  And el estado de orden debe ser "Procesando" en mi cuenta
  And el inventario debe decrementarse por 1 para "Sony WH-1000XM4"
  And el pago debe procesarse por $349.99

Scenario: Manejo de producto sin stock
  Given producto "Limited Edition Watch" tiene 0 inventario
  When intento agregarlo al carrito
  Then debo ver notificación "Fuera de Stock"
  And botón "Agregar al Carrito" debe estar deshabilitado
  And debo ver opción "Notificarme cuando esté disponible"

Scenario: Información de pago inválida
  Given tengo artículos en mi carrito
  When procedo al checkout
  And ingreso número de tarjeta de crédito inválido "1234 5678 9012 3456"
  And confirmo la orden
  Then debo ver error "Información de pago inválida"
  And orden no debe crearse
  And inventario no debe decrementarse

# Ejemplo: Load testing para validación de performance del sistema
from locust import HttpUser, task, between

class EcommerceUser(HttpUser):
    wait_time = between(1, 3)  # Esperar 1-3 segundos entre requests

    def on_start(self):
        """Login cuando usuario inicia"""
        response = self.client.post("/api/auth/login", json={
            "email": "loadtest@example.com",
            "password": "TestPass123!"
        })
        self.token = response.json()["token"]

    @task(3)
    def browse_products(self):
        """Navegar productos (alta frecuencia)"""
        self.client.get("/api/products", headers={
            "Authorization": f"Bearer {self.token}"
        })

    @task(2)
    def view_product_detail(self):
        """Ver producto específico (frecuencia media)"""
        self.client.get("/api/products/12345", headers={
            "Authorization": f"Bearer {self.token}"
        })

    @task(1)
    def add_to_cart(self):
        """Agregar producto al carrito (menor frecuencia)"""
        self.client.post("/api/cart/items", json={
            "productId": "12345",
            "quantity": 1
        }, headers={
            "Authorization": f"Bearer {self.token}"
        })

    @task(1)
    def view_cart(self):
        """Ver carrito de compras"""
        self.client.get("/api/cart", headers={
            "Authorization": f"Bearer {self.token}"
        })

# Ejecutar con: locust -f system_load_test.py --users 1000 --spawn-rate 50
# Prueba sistema con 1000 usuarios concurrentes, aumentando 50 usuarios por segundo

## UAT Test Case: Generación de Reporte Financiero Mensual

**Test ID:** UAT-FIN-001
**Feature:** Reportes Financieros
**Prioridad:** Alta
**Tester:** Jane Smith (Gerente de Finanzas)
**Fecha:** 2025-10-02

### Requisito de Negocio
Gerentes de finanzas necesitan generar reportes financieros mensuales comprensivos
que resuman ingresos, gastos y márgenes de ganancia por departamento.

### Pre-condiciones
- Usuario tiene rol de Gerente de Finanzas
- Existen datos financieros para Septiembre 2025
- Usuario está autenticado en el sistema

### Pasos de Prueba

1. Navegar a Reportes → Financiero → Resumen Mensual
   - **Esperado:** Página de Resumen Mensual carga en menos de 3 segundos
   - **Real:** _______________
   - **Pasa/Falla:** ___________

2. Seleccionar "Septiembre 2025" del dropdown de mes
   - **Esperado:** Mes seleccionado, formulario se actualiza
   - **Real:** _______________
   - **Pasa/Falla:** ___________

3. Seleccionar "Todos los Departamentos" o departamento específico
   - **Esperado:** Selección de departamento disponible
   - **Real:** _______________
   - **Pasa/Falla:** ___________

4. Hacer clic en botón "Generar Reporte"
   - **Esperado:** Reporte se genera en menos de 10 segundos, indicador de progreso se muestra
   - **Real:** _______________
   - **Pasa/Falla:** ___________

5. Revisar contenidos del reporte para exactitud
   - **Esperado:** Reporte incluye:
     - Ingresos totales por departamento
     - Gastos totales por categoría
     - Cálculos de margen de ganancia
     - Comparación mes a mes
     - Gráficos visuales (tendencia de ingresos, desglose de gastos)
   - **Real:** _______________
   - **Pasa/Falla:** ___________

6. Verificar que números del reporte coinciden con datos fuente
   - **Esperado:** Verificar manualmente que 3 transacciones de muestra aparecen correctamente
   - **Real:** _______________
   - **Pasa/Falla:** ___________

7. Exportar reporte como PDF
   - **Esperado:** PDF se descarga, mantiene formato, incluye todos los datos
   - **Real:** _______________
   - **Pasa/Falla:** ___________

8. Exportar reporte como Excel
   - **Esperado:** Excel se descarga, datos son editables, fórmulas incluidas
   - **Real:** _______________
   - **Pasa/Falla:** ___________

### Criterios de Aceptación de Negocio
- [  ] Reporte refleja exactamente datos financieros
- [  ] Reporte se genera dentro de tiempo aceptable (< 10 segundos)
- [  ] Formato de reporte cumple estándares de negocio
- [  ] Funcionalidad de exportación funciona para PDF y Excel
- [  ] Reporte es comprensible sin conocimiento técnico

### Comentarios/Issues
_____________________________________________________________________
_____________________________________________________________________

### Resultado General: PASA / FALLA / PASA CONDICIONALMENTE

**Firmado:** _____________________ **Fecha:** __________