Fundamentos de Tests de Integración

Los tests de integración verifican cómo múltiples componentes o sistemas trabajan conjuntamente. Mientras que los unit tests prueban bloques individuales de forma aislada, los tests de integración nos dan la seguridad de que módulos, bases de datos y servicios externos se comunican correctamente.

En Resumen

• Los tests de integración verifican la interacción entre componentes o sistemas.
• Encuentran errores que los unit tests puros no detectan.
• Estrategias: Big Bang, Top-Down, Bottom-Up y Sandwich.
• Testcontainers, bases de datos In-Memory locales y entornos de staging son herramientas comunes.

Descripción Técnica Comprimida

Un test de integración reúne varios componentes para validar sus interfaces y comportamiento conjunto. En el proceso, se incluyen dependencias reales como bases de datos, message queues o APIs, o se simulan mediante versiones de prueba ligeras. Los tests de integración son más lentos y complejos que los unit tests, pero cubren escenarios más realistas.

Estrategias de Test de Integración

Big Bang Integration

Se ensamblan y prueban todos los módulos simultáneamente. El enfoque es simple, pero difícil de depurar porque las fuentes de error son difíciles de localizar.

Top-Down Integration

Las pruebas comienzan en la capa de control superior y avanzan hacia abajo. Los módulos inferiores que aún no están disponibles se reemplazan con stubs.

Bottom-Up Integration

Las pruebas comienzan con los módulos inferiores y avanzan hacia arriba. Los drivers reemplazan los módulos superiores aún no integrados.

Sandwich Integration

Combinación de Top-Down y Bottom-Up. Se prueba simultáneamente desde arriba y hacia abajo para obtener resultados más rápidamente.

Herramientas Importantes

• Testcontainers: Contenedores Docker para bases de datos, message brokers y caches en tests.
• H2 / SQLite: Bases de datos In-Memory ligeras para tests rápidos.
• REST Assured: Prueba de APIs HTTP en Java.
• Supertest: Prueba de APIs HTTP en Node.js.
• Spring Boot Test: Tests de integración para aplicaciones Spring.

Ejemplo Práctico: Integración de API con Base de Datos

import unittest
from fastapi.testclient import TestClient
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

from app.main import app, get_db
from app.models import Base

SQLALCHEMY_DATABASE_URL = "sqlite:///./test.db"
engine = create_engine(SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False})
TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

Base.metadata.create_all(bind=engine)

def override_get_db():
    db = TestingSessionLocal()
    try:
        yield db
    finally:
        db.close()

app.dependency_overrides[get_db] = override_get_db
client = TestClient(app)

class TestItemApi(unittest.TestCase):
    def test_create_item(self):
        response = client.post("/items/", json={"name": "Tastatur", "price": 49.99})
        self.assertEqual(response.status_code, 201)
        self.assertEqual(response.json()["name"], "Tastatur")

    def test_read_item(self):
        client.post("/items/", json={"name": "Maus", "price": 19.99})
        response = client.get("/items/1")
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json()["name"], "Maus")

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

Ventajas y Desventajas

Ventajas

• Detección de errores más realista: Los errores de interfaz, problemas de formato y fallos de dependencias se hacen visibles.
• Cobertura de flujos reales: Se validan integraciones con bases de datos, APIs y messaging.
• Confianza en la arquitectura: Se comprueba que el cableado de componentes es correcto.
• Detección temprana de problemas: Los problemas de integración se descubren antes de llegar a producción.

Desventajas

• Tiempo de ejecución mayor: Los tests de integración son más lentos que los unit tests.
• Mayor costo de mantenimiento: Los datos de prueba, entornos y estados deben gestionarse.
• Localización de errores: Las fuentes de error son más difíciles de aislar que en unit tests.
• Tests inestables: Las dependencias externas o sensibles al tiempo pueden causar tests frágiles.

Puntos Clave para Exámenes

• Diferencia entre unit tests e integration tests.
• Las cuatro estrategias de integration tests.
• Ventajas y limitaciones de los tests de integración.
• Herramientas importantes para tests de integración con bases de datos y APIs.
• Manejo de datos de prueba y dependencias.

Preguntas Típicas de Examen (con Respuesta Breve)

1. ¿Qué verifica un test de integración? La interacción de múltiples componentes o sistemas.

2. Nombra dos estrategias de integration tests. Big Bang, Top-Down, Bottom-Up o Sandwich.

3. ¿Qué es un stub? Un módulo de reemplazo simplificado para un componente que aún no está disponible.

4. ¿Por qué los tests de integración son más lentos que los unit tests? Porque incluyen bases de datos reales, redes o servicios externos.

5. ¿Cuál es una ventaja de los tests de integración respecto a los unit tests? Encuentran errores de interfaz y problemas en la interacción entre componentes.

Continúa en la Ruta de Aprendizaje de Software Testing

El siguiente artículo en la ruta de aprendizaje de Software Testing cubre E2E Tests Grundlagen, explicando cómo se prueban flujos completos de usuario.

Fuentes Principales

1. https://martinfowler.com/bliki/IntegrationTest.html
2. https://www.testcontainers.org
3. https://en.wikipedia.org/wiki/Integration_testing