Aprender a testear aplicaciones que dependen de llamadas HTTP puede ser un desafío si dependemos únicamente de servicios externos. Mock Web Server es una herramienta práctica que permite simular respuestas HTTP en ambientes controlados, sin necesidad de conexión a Internet. Esto facilita verificar cómo tu aplicación maneja respuestas exitosas o fallidas con diferentes formatos de datos.

¿Qué es Mock Web Server y para qué sirve?

Mock Web Server es una herramienta que permite simular respuestas HTTP para testear componentes de red en tus aplicaciones. Usándolo, puedes verificar que tu lógica maneja adecuadamente diferentes tipos de respuestas de forma controlada y segura, lo que evita depender de entornos externos variables durante el desarrollo.

Entre sus principales usos se pueden resaltar:

• Simular escenarios exitosos y fallidos (códigos HTTP como 200, 404).
• Controlar respuestas mediante JSON específicos.
• Asegurar una cobertura completa y consistente en pruebas automatizadas.

¿Cómo integrar Mock Web Server en pruebas con Retrofit?

Para integrar esta herramienta en tests junto con Retrofit en Kotlin, sigue estos pasos clave:

Configuración inicial de Mock Web Server

En el método setup de tus pruebas:

• Inicializa la instancia de Mock Web Server.
• Configura Retrofit para usar el Mock Web Server como URL Base.
• Usa application/json en tu configuración de pruebas para respuestas consistentes.

Ejemplo básico de configuración con Retrofit:

fullscreen
lateinit var mockWebServer: MockWebServer
lateinit var mockApi: UserApi

@Before
fun setUp() {
    mockWebServer = MockWebServer()
    mockWebServer.start()

    mockApi = Retrofit.Builder()
        .baseUrl(mockWebServer.url("/"))
        .addConverterFactory(Json.asConverterFactory("application/json".toMediaType()))
        .build()
        .create(UserApi::class.java)
}

@After
fun tearDown() {
    mockWebServer.shutdown()
}

Simular respuestas HTTP específicas

Mediante Mock Web Server, puedes encolar diferentes respuestas HTTP según las necesidades del test mediante el método enqueue. Cada respuesta incluye un código HTTP y un cuerpo de respuesta JSON:

fullscreen
mockWebServer.enqueue(
    MockResponse()
        .setResponseCode(200)
        .setBody("""
            {
                "id": 1,
                "username": "test user"
            }
        """.trimIndent())
)

Probando respuestas HTTP específicas

Puedes validar distintos escenarios mediante tus casos de prueba. A continuación un ejemplo de cómo testear una respuesta exitosa y verificar la consistencia del resultado:

fullscreen
@Test
fun givenValidUserId_whenGetProfileWithMockWebServer_thenReturnsProfile() = runTest {
    val user = User(id = 1, username = "test user")
    mockWebServer.enqueue(MockResponse().setResponseCode(200).setBody("{\"id\":1,\"username\":\"test user\"}"))

    val repository = UserRepositoryImpl(mockApi)
    val result = repository.getProfile(1)

    assertTrue(result.isSuccess)
    assertEquals(user, result.getOrThrow())
}

Simular errores HTTP y excepciones

Para probar el manejo de errores HTTP (como los códigos 400), utiliza respuestas encoladas con códigos de error específicos:

fullscreen
mockWebServer.enqueue(
    MockResponse().setResponseCode(404)
)

Luego prueba que la excepción esperada se lance correctamente dentro del repositorio.

¿Cómo validar el manejo correcto de excepciones HTTP?

Para verificar fallos o respuestas erróneas en tus tests, asegura que se disparen excepciones específicas como la HTTPException y valida su captura correcta:

fullscreen
@Test
fun givenInvalidUserId_whenGetProfile_returnsError() = runTest {
    mockWebServer.enqueue(MockResponse().setResponseCode(404))

    val repository = UserRepositoryImpl(mockApi)
    val result = repository.getProfile(-1)

    assertTrue(result.isFailure)
    assertTrue(result.exceptionOrNull() is HttpException)
}

Estas pruebas aseguran que tu aplicación maneje adecuadamente posibles errores de red y mejora la calidad y robustez de tu código.