GuíaBásico
Guía de Fundamentos de Testing y TDD
Aprende a probar software desde cero: qué hace bueno a un test y el ciclo TDD (rojo-verde-refactor), con las manos en el teclado sobre lógica de dominio pura en Python con `pytest`. Empiezas escribiendo tests a mano con `assert`, sin ningún framework, para que el concepto quede en tus manos antes de que una herramienta lo automatice; después instalas `pytest` y practicas el ritmo test-first hasta que escribir el test primero cambie tu forma de diseñar el código. La guía cubre clases de equivalencia y valores límite, `pytest.raises` para excepciones, `@pytest.mark.parametrize` para tablas de casos, tests que se leen bien y no se rompen, cobertura con `coverage.py` (y por qué el 100% no es la meta), y termina enseñándote a oler un test que estorba y a controlar tu primera dependencia con un doble de prueba simple. Todo el recorrido trabaja sobre Reservo, un sistema de reservas de salas de coworking hecho de lógica pura en memoria (sin base de datos ni red), perfecto para practicar sin que la infraestructura distraiga. Cierra con un proyecto final donde construyes de cero, con TDD, la política de cancelación con reembolso de Reservo.
- 64
- lecciones
- 8
- módulos
- Inglés · Español
- disponible en
- Sí
- certificado
- Gratis
- acceso
Resultados
Lo que vas a poder hacer
- Definir qué hace bueno a un test (rápido, aislado, determinista, legible) y escribir tests a mano con `assert` antes de conocer un framework
- Instalar y usar `pytest`: descubrimiento de tests, aserciones, correr subconjuntos con `-k`/`-x`/`-q`, y leer el output rojo/verde
- Practicar el ciclo TDD completo (rojo-verde-refactor) test-first, viendo cómo escribir el test primero cambia el diseño del código
- Cubrir casos y límites con clases de equivalencia, valores límite, `pytest.raises` para excepciones y `@pytest.mark.parametrize` para tablas de casos
- Escribir tests que se leen bien y no se rompen: nombres que documentan, patrón Arrange-Act-Assert, un concepto por test, y fixtures básicas de `pytest`
- Medir y leer cobertura con `coverage.py`/`pytest --cov` sin volverla un fetiche, entendiendo qué NO ve la cobertura
- Reconocer test smells (probar implementación, sobre-testing, tests lentos o no deterministas) y usar tu primer test double (un `Clock`/stub) para controlar el tiempo
- Aplicar TDD de punta a punta en un proyecto real: construir la política de cancelación con reembolso de Reservo, de rojo a verde a refactor
Antes de empezar
Qué necesitas traer
Es para ti si...
- Devs Python que nunca escribieron un test o lo hacen "porque toca", sin entender qué hace bueno a uno
- Devs que quieren aprender TDD de forma disciplinada, con el ciclo rojo-verde-refactor practicado paso a paso
- Equipos que corren `pytest` sin dominarlo del todo (descubrimiento de tests, `parametrize`, fixtures básicas)
- Devs que persiguen el 100% de cobertura sin saber qué mide en realidad y qué se les escapa
Requisitos y materiales
- Conocimientos básicos de Python (funciones, excepciones, clases, listas y diccionarios)
- Python 3.10+ instalado localmente (la guía se verificó con Python 3.14 y pytest 9.1.1)
- Ningún conocimiento previo de testing ni de `pytest` — la guía arranca desde cero
Contenido
El temario, módulo por módulo
Abre cualquiera para ver sus lecciones.
- 1. Presentación del módulo: un test es una afirmación ejecutable
- 2. Qué es un test y por qué lo escribimos
- 3. Qué te compran los tests
- 4. El costo de no probar
- 5. La anatomía de un test: Arrange-Act-Assert
- 6. El `assert` por dentro y un corredor hecho a mano
- 7. Qué hace bueno a un test
- 8. Mini-proyecto: tu primer test escrito a mano
- 1. Presentación del módulo: de un `assert` a mano a un corredor de tests
- 2. Instalar pytest y tu primera corrida verde
- 3. Cómo pytest descubre tus tests
- 4. `assert` a secas y por qué el mensaje de pytest es tan bueno
- 5. Leer el output: rojo, verde y el reporte de fallo
- 6. Correr solo lo que importa: `-k`, `-x`, `-q`, `-v`
- 7. Hacer crecer tu suite: un concepto por test
- 8. Proyecto: una suite de pytest para `price_cents`
- 1. Presentación del módulo: rojo, verde, refactor
- 2. Escribir primero el test que falla
- 3. Hacerlo pasar con el código más simple
- 4. Refactorizar bajo la barra verde
- 5. El siguiente test: triangulación
- 6. Escribir el test primero cambia el diseño
- 7. El bucle de TDD como hábito
- 8. Proyecto: TDD de `is_available` desde cero
- 1. Presentación del módulo: probar la lógica, no solo el camino feliz
- 2. Clases de equivalencia: menos tests, más casos cubiertos
- 3. Valores límite: donde viven los bugs
- 4. El borde exacto: ¿qué pasa EN 48 horas?
- 5. Probar errores con `pytest.raises`
- 6. `parametrize`: un test, muchos casos
- 7. Elegir los casos que importan
- 8. Proyecto: una suite parametrizada de bordes para `refund_cents`
- 1. Presentación del módulo: un test que pasa no es lo mismo que un buen test
- 2. Nombres que documentan lo que el test verifica
- 3. Arrange-Act-Assert a la vista
- 4. Un concepto por test
- 5. Tests frágiles contra tests de comportamiento
- 6. Fixtures para dejar de repetir el setup
- 7. DRY en los tests sin perder claridad
- 8. Mini-proyecto: refactoriza una suite frágil de Reservo
- 1. Presentación del módulo: la cobertura es un instrumento, no una calificación
- 2. Qué mide la cobertura de líneas
- 3. Correr `coverage.py` sobre Reservo
- 4. Leer el reporte: `Stmts`, `Miss`, `Cover`, `Missing`
- 5. El mito del 100%
- 6. Cobertura de ramas contra cobertura de líneas
- 7. Lo que la cobertura no ve: el test sin `assert`
- 8. Mini-proyecto: sube la cobertura y encuentra el hueco que no delata
- 1. Presentación del módulo: cuándo un test estorba
- 2. Probar el comportamiento, no la implementación
- 3. Sobre-testing: cuando más tests hacen daño
- 4. Tests lentos y tests no deterministas (flaky)
- 5. El problema de `datetime.now()`
- 6. Inyecta el reloj: pasa `now` como parámetro
- 7. Tu primer doble: un reloj fijo (`FixedClock`)
- 8. Mini-proyecto: haz determinista la prueba de `cancel` con un `FixedClock`
- 1. Presentación del módulo: el método por encima de la cantidad
- 2. La primera prueba roja de `cancel`
- 3. Hacerla verde con lo mínimo
- 4. Los bordes de reembolso dentro de `cancel`
- 5. Un reloj falso para un `now` determinista
- 6. Refactorizar `cancel` bajo barra verde
- 7. La cobertura del feature y el hueco que no delata
- 8. Proyecto: entrega la feature de cancelación
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!