GuíaIntermedio
Guía de Contract e Integration Testing
Aprende dos disciplinas que empiezan justo donde terminan los tests unitarios con dobles: el contract testing (verificar que dos componentes que se hablan están de acuerdo en su contrato, consumer/provider) y el integration testing (verificar que los componentes funcionan JUNTOS de verdad, cruzando la costura, con recursos reales). El hilo conductor: un test unitario en verde puede esconder una integración rota, porque el doble mentía. Sobre el caso Reservo extendido con un `BookingRepository` real basado en SQLite (junto al fake ya conocido), practicas escribir un contract test consumer-driven que corre la misma batería contra el fake y contra lo real, verificar el contrato desde los dos lados (consumer y provider), y escribir integration tests que crucen las fronteras reales del sistema — una transacción de SQLite, un archivo, un límite HTTP mínimo — decidiendo qué mantener real y qué doblar. Cierra con aislamiento de datos en integración (rollback de transacciones, recursos temporales) y un proyecto final que combina un contrato verificado contra ambas implementaciones con una prueba de integración completa del `BookingService`.
- 64
- lecciones
- 8
- módulos
- Inglés · Español
- disponible en
- Sí
- certificado
- Gratis
- acceso
Resultados
Lo que vas a poder hacer
- Entender por qué un test unitario en verde puede esconder una integración rota, y el lugar de contratos e integración en la pirámide de tests
- Reconocer cuándo un doble (fake/stub) DIVERGE del componente real, y cómo ese bug pasa el unit test pero explota en producción
- Escribir un contract test consumer-driven: un spec compartido que corre la misma batería de pruebas contra el fake y contra la implementación real
- Verificar un contrato desde los dos lados — el consumer test ("mando X, espero Y") y el provider test ("dado X, devuelvo Y") — para cazar cambios incompatibles antes de desplegar
- Escribir integration tests que crucen la costura de verdad, decidiendo qué mantener real y qué doblar en una prueba de integración
- Probar en las fronteras reales del sistema: una transacción de SQLite, un archivo, una llamada HTTP mínima, manteniendo esas pruebas rápidas y deterministas
- Aislar datos y estado en integración: rollback de transacciones, fixtures de recursos reales (crear y destruir una base de datos temporal), pruebas independientes y repetibles
- Combinar contract e integration testing en un caso real: verificar un repositorio contra su fake y su implementación SQLite, y probar el servicio completo contra el repositorio real
Antes de empezar
Qué necesitas traer
Es para ti si...
- Devs que ya usan dobles de prueba con soltura y quieren verificar que esos dobles no mienten sobre el comportamiento real
- Equipos con más de un servicio o componente que se comunican entre sí y necesitan detectar contratos rotos antes del despliegue
- Devs que quieren dar el salto de "unit test con fake" a "probar contra una base de datos y un límite HTTP reales" sin adoptar todavía un framework web completo
- Devs que están preparando la base para testear una app backend real (FastAPI, base de datos de producción) más adelante
Requisitos y materiales
- Guía de Dobles de Prueba y Datos de Test completada (o equivalente: saber usar y construir un fake, un stub, un mock)
- Guía de Fundamentos de Testing y TDD completada (o equivalente: pytest, ciclo TDD, fixtures)
- Python 3.14 y pytest 9.1.1 instalados localmente (`sqlite3` y `http.server` son de la librería estándar; Pact se trata como concepto, no se instala)
Contenido
El temario, módulo por módulo
Abre cualquiera para ver sus lecciones.
- 1. Presentación del módulo: Reservo estrena un repositorio real
- 2. Integración contra unidad
- 3. La pirámide de tests
- 4. Las costuras: dónde se conectan los componentes
- 5. Un unit test verde puede esconder una integración rota
- 6. Tipos de integración
- 7. El costo y el beneficio de los tests de integración
- 8. Mini-proyecto: fake en verde, real en rojo
- 1. Presentación del módulo: el doble que miente
- 2. Por qué los dobles divergen
- 3. Cuando el fake devuelve `None` y el real lanza
- 4. Divergencia de tipos y de orden
- 5. Divergencia de unicidad y transacciones
- 6. Por qué el unit test no lo ve
- 7. El costo en producción
- 8. Mini-proyecto: encuentra la divergencia que el unit test no delata
- 1. Presentación del módulo: del problema a la cura
- 2. Qué es un contrato
- 3. Contratos consumer-driven
- 4. La batería parametrizada contra el fake y SQLite
- 5. El contrato caza la divergencia del módulo 2
- 6. Contratos de estado contra contratos de interacción
- 7. El concepto de Pact
- 8. Mini-proyecto: escribe el contrato del `BookingRepository`
- 1. Presentación del módulo: el contrato tiene dos lados
- 2. El lado del consumer
- 3. El lado del provider
- 4. La misma batería contra el fake y el real
- 5. Cazar un breaking change del provider
- 6. Cazar una suposición de más del consumer
- 7. Quién posee el contrato: consumer-driven
- 8. Mini-proyecto: verifica el contrato desde ambos lados
- 1. Presentación del módulo: ahora sí, las piezas juntas
- 2. Qué es una prueba de integración de verdad
- 3. `BookingService` y SQLite, juntos
- 4. Qué doblar y qué mantener real
- 5. Test solitario contra sociable
- 6. La integración caza lo que el unit no
- 7. El costo de la integración
- 8. Mini-proyecto: una integración `book`→`get` contra SQLite
- 1. Presentación del módulo: las fronteras del sistema
- 2. Qué es una frontera
- 3. La frontera de base de datos: una transacción real
- 4. `:memory:` contra un archivo
- 5. La frontera de archivos con `tmp_path`
- 6. La frontera HTTP con `http.server` real
- 7. Rápido y determinista: cuándo tocar lo real y cuándo doblar
- 8. Mini-proyecto: las tres fronteras de Reservo
- 1. Presentación del módulo: el estado que no se va solo
- 2. Por qué el estado real compartido contamina
- 3. El rollback de transacción como aislamiento
- 4. Fixtures de BD temporal con yield
- 5. `:memory:` contra archivo temporal
- 6. Sembrar datos de integración
- 7. Independientes y repetibles
- 8. Mini-proyecto: aísla una suite de integración de Reservo
- 1. Presentación del módulo: el proceso completo de Reservo
- 2. Escribir el contrato consumer-driven del repositorio
- 3. Verificar el contrato contra el `FakeBookingRepository`
- 4. Verificar el contrato contra el `SqliteBookingRepository` real
- 5. La prueba de integración de punta a punta: `book`→`get`→`cancel`
- 6. Aislar la integración con fixture y rollback
- 7. Cazar un breaking change con el contrato
- 8. Proyecto: contrato + integración de Reservo
Dudas frecuentes
Lo que suele preguntarse
Sin límite. Es una guía gratuita: entras cuando quieras, las veces que quieras.
No. Los módulos están ordenados de menos a más, pero puedes saltar al que necesites. Tu progreso se guarda por lección.
Lo que haga falta está en «Qué necesitas traer», arriba. Si no aparece nada ahí, puedes empezar desde cero.
En el grupo de WhatsApp del Club, y cada quince días hay un live con un instructor donde se resuelven dudas en vivo.
Sí. Al terminar todas las lecciones se emite automáticamente, con un código verificable que puedes compartir en LinkedIn.
Empieza cuando quieras
Lo que dicen los estudiantes
Estas reseñas son de estudiantes inscritos que completaron al menos el 50% del curso. Moderamos las reseñas solo por motivos de contenido (spam, lenguaje ofensivo, datos personales), nunca por ser críticas o negativas.
Aún no hay reseñas aprobadas.
¡Sé el primero en compartir tu experiencia!