Errores que se pueden contar

src/commonMain/kotlin/com/sebastiannarvaez/pokedex/core/AppError.kt

package com.sebastiannarvaez.pokedex.core
 
/**
 * Los cuatro errores que la app sabe contar.
 * Cuatro, no catorce: un error de la app no es un código HTTP, es una de las
 * pocas cosas distintas que se le pueden decir a una persona.
 */
sealed interface AppError {                       // lista cerrada de casos
    /** No hay red, o el servidor no contesta. */
    data object SinConexion : AppError            // sin datos: solo hay una instancia
 
    /** El servidor contestó, pero tardó demasiado. */
    data object Lento : AppError
 
    /** El servidor dijo que no: 4xx o 5xx. */
    data class Servidor(val codigo: Int) : AppError   // este sí lleva un dato: el código HTTP
 
    /** Cualquier otra cosa. Se guarda su mensaje para poder registrarla. */
    data class Inesperado(val causa: String) : AppError
}

import io.ktor.client.network.sockets.ConnectTimeoutException   // no se pudo conectar a tiempo
import io.ktor.client.plugins.HttpRequestTimeoutException       // la petición tardó más de la cuenta
import io.ktor.client.plugins.ResponseException                 // el servidor respondió con 4xx o 5xx
import io.ktor.http.HttpStatusCode                              // los códigos HTTP con nombre
import kotlinx.coroutines.CancellationException                 // «alguien canceló esta corrutina»
import kotlinx.io.IOException                                   // fallo de entrada/salida: la red se cayó

fun Throwable.aAppError(): AppError = when (this) {        // `this` es la excepción
    // La cancelación NO se traduce: se vuelve a lanzar (explicado abajo). `throw this`
    // lanza otra vez la propia excepción; `throw` es una expresión, así que vale
    // como resultado de una rama del `when`.
    is CancellationException -> throw this
    // Los dos timeouts también son IOException, así que van ANTES: el `when`
    // se queda con la primera rama que encaja. La coma une dos condiciones:
    // la rama vale si es cualquiera de las dos.
    is HttpRequestTimeoutException, is ConnectTimeoutException -> AppError.Lento
    // El servidor contestó con 4xx o 5xx. (Ktor solo lanza esta excepción si se
    // lo pides con `expectSuccess`: se activa en la lección siguiente.)
    is ResponseException -> AppError.Servidor(response.status.value)
    // Cualquier otro fallo de entrada/salida: no hay red.
    is IOException -> AppError.SinConexion
    // Lo demás: se guarda el mensaje; si no hay, el nombre de la clase de la
    // excepción (`this::class` es su clase, `simpleName` su nombre sin paquete y
    // `orEmpty()` cambia un `null` por un texto vacío).
    else -> AppError.Inesperado(message ?: this::class.simpleName.orEmpty())
}
 
/** Si vale la pena ofrecer un botón de reintentar. */
val AppError.esReintentable: Boolean                       // propiedad de extensión
    get() = when (this) {
        // Sin `is`: `SinConexion` y `Lento` son objetos únicos y se comparan por igualdad.
        AppError.SinConexion, AppError.Lento -> true       // la red puede volver
        // Un 5xx es un servidor que quizá vuelva; un 4xx va a seguir siendo 4xx.
        // `InternalServerError` es el 500, así que «>= 500» son los 5xx.
        is AppError.Servidor -> codigo >= HttpStatusCode.InternalServerError.value
        is AppError.Inesperado -> false                    // no sabemos qué es: no prometemos nada
    }

package com.sebastiannarvaez.pokedex.core
 
/**
 * El error tal y como lo pinta una pantalla.
 * Lo comparten las dos apps: si cada una escribiera su texto, una diría
 * «sin conexión» y la otra «no hay internet».
 */
data class UiError(
    val titulo: String,                // lo que va en grande
    val detalle: String,               // la frase de debajo
    val sePuedeReintentar: Boolean,    // si se dibuja el botón «Reintentar»
)
 
fun AppError.aUiError(): UiError = when (this) {   // exhaustivo: un caso nuevo de AppError rompe aquí
    AppError.SinConexion -> UiError(
        titulo = "Sin conexión",
        detalle = "Revisa tu red e inténtalo otra vez.",
        sePuedeReintentar = true,
    )
    AppError.Lento -> UiError(
        titulo = "La respuesta tardó demasiado",
        detalle = "El servidor no contestó a tiempo.",
        sePuedeReintentar = true,
    )
    is AppError.Servidor -> UiError(
        titulo = "PokeAPI no responde",
        detalle = "El servidor devolvió un error $codigo.",   // `$codigo` mete el número en el texto
        sePuedeReintentar = esReintentable,                   // 503 sí, 404 no
    )
    is AppError.Inesperado -> UiError(
        titulo = "Algo se rompió",
        detalle = causa,
        sePuedeReintentar = false,
    )
}

package com.sebastiannarvaez.pokedex.core
 
import kotlinx.coroutines.CancellationException
import kotlinx.io.IOException
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFailsWith
import kotlin.test.assertFalse
import kotlin.test.assertTrue
 
class AppErrorTest {
 
    @Test
    fun unFalloDeRedEsSinConexion() {
        // `IOException` es lo que lanza de verdad un socket caído (el «socket» es la
        // conexión abierta con el servidor; si la red falla, se corta y salta esto).
        assertEquals(AppError.SinConexion, IOException("socket cerrado").aAppError())
    }
 
    @Test
    fun laCancelacionNoSeTraduce() {
        // `assertFailsWith` pasa si el bloque lanza esa excepción: aquí
        // queremos que `aAppError` NO la convierta en un AppError.
        assertFailsWith<CancellationException> {
            CancellationException("la vista se fue").aAppError()
        }
    }
 
    @Test
    fun soloSeOfreceReintentarCuandoTieneSentido() {
        assertTrue(AppError.SinConexion.esReintentable)
        assertTrue(AppError.Lento.esReintentable)
        assertTrue(AppError.Servidor(503).esReintentable)
        assertFalse(AppError.Servidor(404).esReintentable)     // seguirá siendo 404
        assertFalse(AppError.Inesperado("vaya").esReintentable)
    }
 
    @Test
    fun lasDosAppsPintanElMismoTexto() {
        val error = AppError.SinConexion.aUiError()
 
        assertEquals("Sin conexión", error.titulo)
        assertTrue(error.sePuedeReintentar)
    }
 
    @Test
    fun unErrorDelServidorLlevaSuCodigoAlTexto() {
        val error = AppError.Servidor(503).aUiError()
 
        assertTrue(error.detalle.contains("503"), "detalle inesperado: ${error.detalle}")
        assertTrue(error.sePuedeReintentar)
    }
}

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

        if (falla) error("sin red")

        assertTrue(resultado is PagingSource.LoadResult.Error)   // esta línea ya existe
        // Y ese fallo de red tiene que poder reintentarse. `assertTrue(… is …)` ya
        // le dijo a Kotlin que `resultado` es un `Error`, así que se puede leer su
        // `throwable` sin convertirlo.
        val error = resultado.throwable.aAppError()
        assertTrue(error.esReintentable, "no se puede reintentar: $error")

java.lang.AssertionError: no se puede reintentar: Inesperado(causa=sin red)