23. Dobles de prueba en integración: stubs, fakes y servicios simulados

23.1 Introducción

En una prueba de integración no siempre usamos todas las dependencias reales. A veces necesitamos reemplazar una dependencia por una versión controlada para evitar costos, reducir inestabilidad, simular errores o probar un escenario difícil de producir con el sistema real.

Estos reemplazos se conocen como dobles de prueba. En este tema nos enfocaremos en tres formas habituales dentro de pruebas de integración: stubs, fakes y servicios simulados.

El objetivo no es memorizar nombres, sino entender cuándo conviene reemplazar una dependencia y qué riesgos aparecen al hacerlo.

23.2 Qué es un doble de prueba

Un doble de prueba es un componente que reemplaza a una dependencia real durante una prueba. Su función es permitir que el sistema bajo prueba avance sin usar la dependencia verdadera.

En integración, puede reemplazar:

  • Una API externa.
  • Un servicio interno que todavía no está disponible.
  • Un proveedor de pagos.
  • Un servicio de correo.
  • Un almacenamiento externo.
  • Una cola o consumidor real.
Un doble de prueba debe ayudar a controlar la prueba sin ocultar el riesgo que realmente queremos verificar.

23.3 Por qué usar dobles en integración

Usar componentes reales aumenta el realismo, pero no siempre es práctico. Los dobles de prueba pueden ser útiles cuando una dependencia real:

  • No está disponible durante el desarrollo.
  • Es lenta o inestable.
  • Tiene costo por uso.
  • Genera efectos secundarios reales.
  • No permite simular ciertos errores fácilmente.
  • Hace que la prueba sea difícil de repetir.

El doble permite controlar respuestas y condiciones para enfocar la prueba en una integración concreta.

23.4 Qué es un stub

Un stub es un reemplazo simple que devuelve respuestas predefinidas. No intenta comportarse como un sistema completo; solo responde lo necesario para el caso de prueba.

Ejemplos:

  • Un stub de pagos que siempre devuelve “aprobado”.
  • Un stub de stock que devuelve “hay disponibilidad”.
  • Un stub de usuarios que devuelve un usuario fijo.
  • Un stub de clima que devuelve una respuesta conocida.

Los stubs son útiles para pruebas simples y controladas, pero pueden volverse poco realistas si no respetan el contrato real.

23.5 Qué es un fake

Un fake es una implementación funcional simplificada de una dependencia. A diferencia de un stub, suele tener algo de comportamiento interno.

Ejemplos:

  • Un repositorio en memoria.
  • Un servidor de correo falso que guarda mensajes enviados.
  • Un almacenamiento local que imita un proveedor externo.
  • Una cola simple en memoria para pruebas.

Un fake puede ser más flexible que un stub, pero también requiere mantenimiento para no alejarse demasiado del comportamiento real.

23.6 Qué es un servicio simulado

Un servicio simulado reemplaza a un servicio real y responde a llamadas como si fuera ese servicio. Puede ejecutarse como un proceso local, un servidor HTTP de prueba o una herramienta específica de simulación.

Puede simular:

  • Respuestas exitosas.
  • Errores de validación.
  • Timeouts.
  • Credenciales inválidas.
  • Respuestas con datos incompletos.
  • Distintos códigos de estado.

Es especialmente útil para probar integraciones con APIs externas o servicios internos que no queremos levantar en cada ejecución.

23.7 Diferencias principales

La siguiente tabla resume las diferencias:

Tipo Idea principal Ejemplo
Stub Respuesta fija o muy simple. Pago siempre aprobado.
Fake Implementación simplificada con comportamiento. Repositorio en memoria que guarda registros.
Servicio simulado Servicio de prueba que imita una dependencia. API falsa de pagos con escenarios configurables.

23.8 Ventajas de usar dobles

Los dobles de prueba pueden aportar varias ventajas:

  • Reducen dependencia de servicios inestables.
  • Permiten probar errores difíciles de provocar.
  • Hacen la prueba más rápida.
  • Evitan costos o efectos reales.
  • Facilitan ejecutar pruebas localmente.
  • Permiten trabajar cuando una dependencia todavía no existe.

Estas ventajas son valiosas, siempre que el doble represente bien el aspecto del contrato que la prueba necesita.

23.9 Riesgos de usar dobles

El principal riesgo es obtener una falsa confianza. Si el doble se comporta de forma distinta al sistema real, la prueba puede pasar aunque la integración real falle.

Riesgos comunes:

  • El doble acepta datos que el servicio real rechazaría.
  • El doble devuelve siempre respuestas perfectas.
  • El contrato real cambia y el doble no se actualiza.
  • El fake no reproduce restricciones importantes.
  • La prueba simula tanto que ya no verifica integración relevante.

Por eso cada doble debe tener un propósito claro y mantenerse alineado con la dependencia que reemplaza.

23.10 Cuándo conviene usar un stub

Un stub conviene cuando necesitamos una respuesta simple y estable para avanzar en el escenario.

Ejemplos:

  • El objetivo es probar la integración entre servicio y base de datos, no el proveedor externo.
  • Necesitamos que una dependencia devuelva un valor fijo.
  • Queremos probar un error específico con una respuesta predefinida.
  • La dependencia real no aporta valor al objetivo de esa prueba.

Si el comportamiento de la dependencia es complejo, un stub puede ser insuficiente.

23.11 Cuándo conviene usar un fake

Un fake conviene cuando necesitamos una dependencia que tenga comportamiento, pero sin usar el recurso real.

Ejemplos:

  • Guardar correos enviados para luego verificarlos.
  • Usar una cola en memoria para pruebas pequeñas.
  • Guardar archivos en una carpeta temporal en lugar de almacenamiento externo.
  • Usar un repositorio en memoria para aislar una integración de capas superiores.

El fake debe comportarse de manera suficientemente parecida para el riesgo que se quiere cubrir.

23.12 Cuándo conviene usar un servicio simulado

Un servicio simulado conviene cuando la dependencia se comunica por red, protocolo o API y necesitamos probar solicitudes y respuestas.

Casos típicos:

  • APIs externas.
  • Servicios internos no disponibles localmente.
  • Pruebas de timeouts y errores controlados.
  • Contratos con respuestas múltiples.
  • Escenarios donde el proveedor real tiene costo o efectos secundarios.

El servicio simulado debe validar que la solicitud recibida tenga la forma esperada, no solo devolver respuestas automáticas.

23.13 Mantener dobles alineados con contratos

Para que un doble sea útil, debe reflejar el contrato relevante de la dependencia real.

Buenas prácticas:

  • Actualizar el doble cuando cambia el contrato.
  • Probar campos obligatorios y tipos de datos.
  • Incluir errores comunes, no solo éxito.
  • Evitar respuestas demasiado genéricas.
  • Comparar periódicamente con el comportamiento real o sandbox.

Un doble desactualizado puede ser peor que no tener prueba, porque genera confianza equivocada.

23.14 Ejemplo: servicio de pagos simulado

Supongamos una integración con un proveedor de pagos. Un servicio simulado podría responder distintos escenarios:

Escenario Respuesta simulada Qué verifica la prueba
Pago aprobado Estado aprobado e identificador de transacción. La orden queda pagada.
Pago rechazado Estado rechazado y código de motivo. La orden no queda confirmada.
Timeout Demora mayor al máximo configurado. El sistema maneja la espera de forma controlada.
Respuesta inválida Falta un campo obligatorio. El sistema detecta contrato inesperado.

23.15 Ejemplo: correo falso

Para probar una integración con correo, no siempre queremos enviar mensajes reales. Un fake de correo puede guardar los mensajes en memoria o en una carpeta de prueba.

La prueba puede verificar:

  • Destinatario correcto.
  • Asunto esperado.
  • Contenido principal.
  • Cantidad de mensajes enviados.
  • No envío cuando la operación falla.

Este fake permite verificar la colaboración sin contactar usuarios reales.

23.16 Errores comunes

Al usar dobles de prueba en integración, suelen aparecer errores como:

  • Simular todas las dependencias y no probar ninguna integración real.
  • Usar stubs demasiado simples para contratos complejos.
  • No actualizar el doble cuando cambia la dependencia real.
  • No probar errores importantes.
  • Usar fakes que no respetan restricciones del sistema real.
  • No documentar qué dependencias fueron reemplazadas.
  • Confundir una prueba con dobles con una prueba completa del flujo real.

23.17 Lista de verificación

Antes de usar un doble en una prueba de integración, conviene preguntar:

  • ¿Qué dependencia real reemplaza?
  • ¿Por qué conviene reemplazarla en esta prueba?
  • ¿Qué parte del contrato debe respetar?
  • ¿Incluye respuestas de error relevantes?
  • ¿Puede quedar desactualizado respecto del sistema real?
  • ¿La prueba sigue verificando una integración importante?
  • ¿Está claro qué no cubre esta prueba?

23.18 Qué debes recordar de este tema

  • Los dobles de prueba reemplazan dependencias reales durante una prueba.
  • Un stub devuelve respuestas simples predefinidas.
  • Un fake implementa comportamiento simplificado.
  • Un servicio simulado imita una dependencia, normalmente a nivel de comunicación.
  • Los dobles ayudan a controlar pruebas, pero pueden generar falsa confianza si no respetan el contrato real.
  • Debe quedar claro qué dependencia se reemplazó y por qué.

23.19 Conclusión

Los dobles de prueba son herramientas útiles para diseñar pruebas de integración prácticas, rápidas y controladas. Permiten simular situaciones difíciles, evitar efectos reales y trabajar aunque una dependencia no esté disponible.

Pero deben usarse con criterio. Una prueba que reemplaza demasiadas dependencias puede dejar de verificar la integración que importa. El equilibrio está en usar dobles para controlar lo que queda fuera del objetivo, sin ocultar el riesgo principal.

En el próximo tema veremos cuándo usar componentes reales y cuándo simular dependencias.