TDD — Intermedio

Curso dirigido a desarrolladores que ya dominan los fundamentos del ciclo Red-Green-Refactor y desean consolidar su práctica de TDD en escenarios de mayor complejidad. A lo largo de las ocho horas, los participantes profundizarán en la toma de decisiones sobre granularidad de tests, selección de dobles de prueba y gestión del cambio de requisitos en mitad del desarrollo; trabajarán sobre suites reales con falsos positivos y tests frágiles, aplicarán TDD como palanca de diseño para desacoplar dependencias, y finalizarán integrando el flujo completo en un módulo con múltiples casos límite, obteniendo una suite verde, expresiva y resistente a la regresión.

1. Justificar la granularidad elegida para cada test en relación con las responsabilidades del módulo bajo prueba, distinguiendo cuándo ampliar o estrechar el alcance de una unidad.
2. Comparar el uso de mocks, stubs y fakes ante distintas dependencias externas, seleccionando el doble de prueba adecuado para cada escenario.
3. Diseñar una suite de tests para un requisito funcional nuevo, siguiendo estrictamente el ciclo Red-Green-Refactor antes de escribir código de producción.
4. Depurar una suite existente con falsos positivos o tests frágiles, identificando la causa raíz e implementando la corrección sin perder cobertura.
5. Adaptar el ciclo TDD a un requisito que cambia de especificación a mitad del desarrollo, manteniendo la suite en estado verde antes de incorporar el nuevo comportamiento.
6. Diseñar tests que guíen la extracción de una dependencia acoplada hacia una abstracción inyectable, aplicando el ciclo TDD durante la refactorización.
7. Integrar el flujo TDD en un módulo con múltiples casos límite, garantizando que cada caso límite queda cubierto por un test escrito antes de su implementación.

Bloque 1 — Decisiones de diseño de tests (aprox. 2 h) El bloque arranca con el problema de la granularidad: qué cuenta como "una unidad" no es una respuesta fija sino una decisión de diseño ligada a las responsabilidades del módulo. Se analiza cómo justificar esa elección y en qué situaciones conviene ampliar o estrechar el foco. A continuación se revisan en profundidad los tres grandes tipos de dobles de prueba —mocks, stubs y fakes—, comparando su impacto sobre el acoplamiento del test y la legibilidad de la suite, y estableciendo criterios claros para elegir entre ellos cuando hay dependencias externas de naturaleza distinta.

Bloque 2 — TDD aplicado a requisitos nuevos y cambiantes (aprox. 2 h) Partiendo de un requisito funcional real, se practica el ciclo completo Red-Green-Refactor con énfasis en la disciplina de no escribir código de producción sin un test rojo previo. Después se introduce la variante más exigente: el requisito cambia de especificación cuando el desarrollo ya está en marcha. Se trabaja la estrategia de estabilizar la suite en verde antes de incorporar el nuevo comportamiento, distinguiendo las técnicas que minimizan el riesgo de regresión durante la transición.

Bloque 3 — Diagnóstico y saneamiento de suites frágiles (aprox. 2 h) Se presentan los patrones de degradación más comunes en suites de tests reales: falsos positivos, tests que dependen del orden de ejecución, aserciones demasiado amplias y acoplamiento excesivo a detalles de implementación. Mediante ejercicios de depuración sobre código existente, los participantes identifican la causa raíz de cada problema y aplican la corrección preservando la cobertura original, desarrollando así un criterio de calidad sobre la suite que va más allá de la mera cobertura porcentual.

Bloque 4 — TDD como herramienta de diseño y casos límite (aprox. 2 h) El bloque final explora TDD como motor de mejora de diseño: se guía la extracción de una dependencia acoplada hacia una abstracción inyectable escribiendo primero los tests que hacen visible el problema. Se comparan además dos estrategias de avance —baby steps frente a pasos más amplios—, justificando cuál reduce mayor riesgo de regresión ante el mismo problema. El bloque concluye con una práctica integradora en la que los participantes aplican el flujo completo sobre un módulo con múltiples casos límite, asegurando que cada uno queda cubierto antes de implementarlo.

• Ordenador con entorno de desarrollo instalado: lenguaje de programación elegido (Java, Python, JavaScript/TypeScript u otro acordado con el formador), framework de testing asociado y gestor de dependencias.
• IDE o editor con soporte para ejecución de tests en caliente (p. ej. IntelliJ IDEA, VS Code con extensiones de testing, PyCharm).
• Repositorio Git local o acceso a la plataforma de control de versiones del equipo para gestionar las ramas de trabajo durante los ejercicios.
• Acceso a los repositorios de ejercicios del curso (se proporcionará el enlace antes del inicio).

• Conocimiento sólido del ciclo Red-Green-Refactor y capacidad de escribir tests unitarios básicos con un framework estándar (xUnit, Jest, pytest o equivalente).
• Comprensión de los conceptos de cobertura de tests, refactorización segura y responsabilidad única de módulo.
• Experiencia práctica con al menos un lenguaje de programación orientado a objetos o funcional en un entorno de desarrollo local configurado con runner de tests.