Testing del núcleo compartido

./gradlew :shared:jvmTest :shared:testAndroidHostTest :shared:iosSimulatorArm64Test

val servidor = MockEngine { peticion ->                 // este bloque se ejecuta con cada petición
    println("Pidieron: ${peticion.url}")                // `peticion` es lo que el cliente intentó pedir
    respond(                                             // y esto es lo que "contesta el servidor"
        content = """{ "nombre": "Leche", "centimos": 120 }""",           // el cuerpo
        status = HttpStatusCode.OK,                                       // el código de estado: 200
        headers = headersOf(HttpHeaders.ContentType, ContentType.Application.Json.toString()), // avisa de que es JSON
    )
}
val cliente = HttpClient(servidor)                      // el cliente usa este motor en vez de la red
val texto = cliente.get("https://tienda.example/producto") {   // la petición GET de siempre
    parameter("id", 7)                                  // añade `?id=7` a la dirección
}.bodyAsText()                                          // el cuerpo, como texto
println("Recibido: $texto")

Pidieron: https://tienda.example/producto?id=7
Recibido: { "nombre": "Leche", "centimos": 120 }

java.lang.ExceptionInInitializerError
Caused by: java.lang.IllegalStateException: Failed to find HTTP client engine implementation: consider adding client engine dependency. See https://ktor.io/docs/http-client-engines.html

turbine = "1.2.1"

# MockEngine: el motor de mentira. Misma versión que el resto de Ktor.
ktor-client-mock = { module = "io.ktor:ktor-client-mock", version.ref = "ktor" }
# test { … } para recoger un Flow evento a evento.
turbine = { module = "app.cash.turbine:turbine", version.ref = "turbine" }

            // MockEngine y respond { … }: simulan el servidor.
            implementation(libs.ktor.client.mock)
            // En commonTest, no en jvmTest: el test del latido corre también en iOS.
            implementation(libs.turbine)

src/commonTest/kotlin/com/sebastiannarvaez/pokedex/data/network/KtorPokeApiTest.kt

package com.sebastiannarvaez.pokedex.data.network
 
import com.sebastiannarvaez.pokedex.core.AppConfig
import io.ktor.client.engine.mock.MockEngine
import io.ktor.client.engine.mock.respond
import io.ktor.http.ContentType
import io.ktor.http.HttpHeaders
import io.ktor.http.HttpStatusCode
import io.ktor.http.headersOf
import kotlinx.coroutines.test.runTest
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertTrue
 
// Una configuración de mentira con la misma dirección que la de verdad.
// `private`: solo la ve este fichero.
private class FakeConfig : AppConfig {
    override val pokeApiBaseUrl = "https://pokeapi.co/api/v2/"
}
 
// Un recorte de una respuesta real de PokeAPI (la entera ocupa 272 KB).
// Conserva a propósito `base_experience` y `sprites`, dos campos que la app no
// declara: si alguien quita `ignoreUnknownKeys`, el test se pone rojo.
// Dos cambios: la URL de la imagen es inventada y los tipos están en orden
// inverso al real (en la respuesta de verdad, `grass` va primero). Así el test
// comprueba que el cliente no los reordena.
private val DETALLE_JSON = """
{
  "id": 1,
  "name": "bulbasaur",
  "base_experience": 64,
  "height": 7,
  "weight": 69,
  "sprites": { "front_default": "https://example.invalid/1.png" },
  "types": [
    { "slot": 2, "type": { "name": "poison", "url": "https://pokeapi.co/api/v2/type/4/" } },
    { "slot": 1, "type": { "name": "grass", "url": "https://pokeapi.co/api/v2/type/12/" } }
  ]
}
""".trimIndent()
 
// Un recorte del listado, con sus campos `next` y `previous` como los manda la API.
private val PAGINA_JSON = """
{
  "count": 1351,
  "next": "https://pokeapi.co/api/v2/pokemon?offset=2&limit=2",
  "previous": null,
  "results": [
    { "name": "bulbasaur", "url": "https://pokeapi.co/api/v2/pokemon/1/" },
    { "name": "ivysaur", "url": "https://pokeapi.co/api/v2/pokemon/2/" }
  ]
}
""".trimIndent()
 
class KtorPokeApiTest {
 
    // Monta una `PokeApi` real (la de Ktor) cuyo servidor es un MockEngine que
    // siempre contesta `respuesta`. `capturar` recibe la dirección que se pidió.
    private fun api(respuesta: String, capturar: (String) -> Unit = {}): PokeApi {
        // El bloque se ejecuta en cada petición; `peticion` es lo que se pidió.
        val engine = MockEngine { peticion ->
            capturar(peticion.url.toString())
            // Responde un 200 con el JSON, avisando de que es JSON.
            respond(
                content = respuesta,
                status = HttpStatusCode.OK,
                headers = headersOf(HttpHeaders.ContentType, ContentType.Application.Json.toString()),
            )
        }
        // El MockEngine sustituye al motor de la plataforma y nada más: la
        // configuración que se prueba es exactamente la de producción.
        return KtorPokeApi(createHttpClient(FakeConfig(), engine = engine))
    }
 
    @Test
    fun elDetalleIgnoraLosCamposQueNoUsamos() = runTest {
        val detalle = api(DETALLE_JSON).detail(1)
 
        assertEquals(1, detalle.id)
        assertEquals("bulbasaur", detalle.name)
        assertEquals(7, detalle.height)
        // Llegan en el orden del JSON (poison, grass): ordenarlos es cosa del repositorio.
        assertEquals(listOf("poison", "grass"), detalle.types.map { it.type.name })
    }
}

    @Test
    fun elListadoConstruyeLaUrlConLimiteYDesplazamiento() = runTest {
        var pedida = ""
        val pagina = api(PAGINA_JSON, capturar = { pedida = it }).page(limit = 2, offset = 4)
 
        assertTrue(pedida.contains("limit=2"), "url inesperada: $pedida")
        assertTrue(pedida.contains("offset=4"), "url inesperada: $pedida")
        assertTrue(pedida.startsWith("https://pokeapi.co/api/v2/pokemon"), "url inesperada: $pedida")
        assertEquals(1351, pagina.count)
    }
 
    @Test
    fun elIdentificadorSeSacaDeLaUrlDelListado() = runTest {
        val pagina = api(PAGINA_JSON).page(limit = 2, offset = 0)
 
        assertEquals(listOf(1, 2), pagina.results.map { it.id })
    }

io.ktor.serialization.JsonConvertException: Illegal input: Unexpected JSON token at offset 39: Encountered an unknown key 'base_experience' at path: $

src/commonTest/kotlin/com/sebastiannarvaez/pokedex/HeartbeatTest.kt

package com.sebastiannarvaez.pokedex
 
import app.cash.turbine.test
import com.sebastiannarvaez.pokedex.core.AppDispatchers
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.time.Duration.Companion.seconds
import kotlinx.coroutines.CoroutineDispatcher
import kotlinx.coroutines.test.StandardTestDispatcher
import kotlinx.coroutines.test.runTest
 
// Un AppDispatchers de mentira: los tres apuntan al dispatcher de prueba, para
// que `runTest` mande sobre todo lo que lance el código.
private class TestDispatchers(private val d: CoroutineDispatcher) : AppDispatchers {
    override val io = d
    override val default = d
    override val main = d
}
 
class HeartbeatTest {
 
    @Test
    fun elLatidoCuentaDeUnoEnUno() = runTest {
        // `testScheduler` es el reloj virtual de `runTest`: el dispatcher de
        // prueba lo comparte, y así el `delay` del latido salta en vez de esperar.
        val pokedex = Pokedex(TestDispatchers(StandardTestDispatcher(testScheduler)))
 
        // `test` es de Turbine: recoge el flujo y deja pedir sus emisiones de una en una.
        // `timeout` es lo máximo que Turbine espera cada emisión, en tiempo real
        // (no virtual): si el latido no emitiera, el test fallaría a los 5 segundos.
        pokedex.heartbeat().test(timeout = 5.seconds) {
            assertEquals(0, awaitItem())
            assertEquals(1, awaitItem())
            assertEquals(2, awaitItem())
            // El latido no termina nunca: se cancela y se ignoran las que queden.
            cancelAndIgnoreRemainingEvents()
        }
    }
}