Módulo 3: Integration y E2E Tests

Módulo 3: Integration y E2E Tests

Siguiente →

Módulo 3: Integration y E2E Tests

Descripción de la cápsula

Un unit test te dice que calculate_discount(100, 10) retorna 90. Pero no te dice si el endpoint POST /orders aplica correctamente ese descuento cuando recibe un request HTTP real. Y mucho menos te dice si el flujo completo — crear usuario → agregar items → aplicar descuento → confirmar orden — funciona de principio a fin.

En los módulos anteriores dominaste unit tests: funciones aisladas, inputs y outputs, tests rápidos y enfocados. Ahora vas a subir por la test pyramid: integration tests que verifican cómo interactúan los componentes (endpoints, database, servicios), y E2E tests que validan flujos completos de usuario.

Este módulo te da criterio estratégico: cuántos tests en cada nivel, cuándo el costo de un E2E test se justifica, y cómo usar Claude Code para generar tests en los tres niveles con prompts específicos para cada uno. Al final, tendrás una test pyramid completa — la base profesional para cualquier proyecto serio.

Contexto del Módulo

¿Dónde estamos?

Este es el Módulo 3 — último de Phase 1 (Fundamentos TDD con AI).

Lo que ya sabes:

  • ✅ Spec-first methodology y TDD con AI (Módulo 1)
  • ✅ Generar y evaluar unit tests con Claude Code (Módulo 2)
  • ✅ Pytest patterns: AAA, parametrize, fixtures, naming (Módulo 2)

Lo que falta: Tests más allá de funciones aisladas. Verificar que endpoints, databases, y flujos completos funcionan correctamente.

¿Hacia dónde vamos?

Phase 1: Fundamentos TDD con AI
├── Módulo 1: ✅ Spec-first (filosofía)
├── Módulo 2: ✅ Unit tests (técnica base)
└── Módulo 3: ← ESTÁS AQUÍ — Integration y E2E (pyramid completa)

Phase 2: Workflows de Testing
├── Módulo 4: → TDD workflow completo (red-green-refactor con AI)
├── Módulo 5: → Coverage y edge cases
└── Módulo 6: → Mocking, fixtures, validation loops

Después de este módulo completas Phase 1 y tienes todas las piezas fundamentales. Phase 2 las ensambla en workflows productivos.

Objetivo Profesional

Construir test pyramids completas con tests en los tres niveles — unit, integration, E2E — y tener criterio para decidir cuántos tests en cada nivel según el proyecto.

Al final de este módulo podrás:

  • ✅ Explicar la test pyramid y los trade-offs de cada nivel (velocidad vs confianza vs costo)
  • ✅ Usar FastAPI TestClient para integration testing de endpoints HTTP
  • ✅ Crear fixtures para database testing con setup y teardown automático
  • ✅ Implementar E2E tests que validan flujos completos vía API
  • ✅ Generar tests en cada nivel con Claude Code usando prompts diferenciados
  • ✅ Organizar tests por nivel: tests/unit/, tests/integration/, tests/e2e/

Progresión del Módulo

Mapa del Módulo

CápsulaTemaQué aprenderás
02Test Pyramid y trade-offsLos 3 niveles, cuándo usar cada uno, cuántos tests por nivel, la pyramid como estrategia
03API testing con FastAPI TestClientIntegration testing de endpoints: GET, POST, PUT, DELETE con assertions de status, body, headers
04Database testing con fixturesTest databases, seed data, teardown, fixtures para isolation entre tests
05E2E testing — flujos completosTests que validan flujos de usuario completos vía HTTP: crear → leer → actualizar → eliminar
06Proyecto: Test pyramid completaConstruir unit + integration + E2E tests para una API REST de items con Claude Code

Flujo de aprendizaje

Primero entenderás la estrategia (cápsula 02): la test pyramid como framework de decisión. No es "escribe tests en los 3 niveles" — es "entiende los trade-offs y decide cuántos tests en cada nivel según tu proyecto."

Luego dominarás integration testing (cápsulas 03-04): testear endpoints HTTP con FastAPI TestClient y testear interacciones con databases usando fixtures. Este es el nivel medio de la pyramid — más confianza que unit tests, más rápido que E2E.

Después experimentarás E2E testing (cápsula 05): flujos completos que simulan lo que haría un usuario real de tu API. Crear recurso → obtener → actualizar → eliminar → verificar que no existe. Es el nivel más alto de confianza pero también el más costoso.

En el proyecto (cápsula 06) construirás una pyramid completa: unit tests para lógica de negocio, integration tests para endpoints, y E2E tests para flujos. Claude Code genera tests en cada nivel con prompts diferenciados.

Conexión con Proyecto

Proyecto de este módulo: Test pyramid completa

Construirás tests en los tres niveles para una API REST simple de gestión de items (CRUD). La API ya está implementada — tu trabajo es crear la test pyramid con Claude Code.

tests/
├── unit/              ← Tests de funciones aisladas (lógica de negocio)
├── integration/       ← Tests de endpoints HTTP (TestClient)
└── e2e/               ← Tests de flujos completos (crear→leer→update→delete)

Conexión con proyecto final (Módulo 8)

El proyecto final requiere tests en los tres niveles. La pyramid que construyes aquí es el template exacto que replicarás a mayor escala. Si dominas los trade-offs aquí, sabrás exactamente qué testear en cada nivel del proyecto final.

Límites: Qué NO Se Hará en Este Módulo

  • ❌ UI testing (Selenium/Playwright) — E2E en esta guía significa flujos de API, no testing de browser
  • ❌ Microservicios con Docker Compose — Integration testing aquí es TestClient, no orquestación de servicios
  • ❌ Mocking de servicios externos — Se cubre en Módulo 6. Aquí testeamos componentes reales
  • ❌ Coverage metrics — Se cubre en Módulo 5. Aquí evaluamos la pyramid por criterio, no por números
  • ❌ Performance testing — Fuera del scope de esta guía

Evidencia de Éxito

Al terminar este módulo, sabrás que tuviste éxito si:

  • ✅ Puedes explicar la test pyramid y decidir cuántos tests en cada nivel para un proyecto dado
  • ✅ Puedes testear un endpoint de FastAPI con TestClient (status code, response body, headers)
  • ✅ Puedes crear fixtures que preparan y limpian una test database
  • ✅ Puedes escribir un E2E test que valida un flujo completo de CRUD
  • ✅ Completaste el proyecto: pyramid completa con tests en los 3 niveles

Resumen

  • ✅ Este módulo completa Phase 1 expandiendo de unit tests a integration y E2E
  • ✅ La test pyramid es una estrategia de decisión: muchos unit, algunos integration, pocos E2E
  • ✅ Integration tests verifican endpoints y interacciones entre componentes
  • ✅ E2E tests validan flujos completos de usuario vía API
  • ✅ Claude Code genera tests en cada nivel con prompts diferenciados
  • ✅ El proyecto produce una test pyramid completa para una API REST

Próxima cápsula: Test Pyramid y trade-offs — la estrategia detrás de los tres niveles.

Recursos Adicionales

  1. Martin Fowler: Test Pyramid - El artículo original sobre la test pyramid
  2. FastAPI Testing Tutorial - Documentación oficial de testing con FastAPI
  3. pytest Fixtures - Fixtures para database testing
  4. httpx Documentation - Cliente HTTP para E2E testing
  5. Ham Vocke: The Practical Test Pyramid - Guía práctica detallada de la pyramid

Módulo 3 — Testing with Claude Code Guide De funciones aisladas a sistemas completos

← AnteriorProyecto del Módulo: Unit Test Suite GeneradaSiguiente →La Test Pyramid: Estrategia y Trade-offs