Probar la paginación

src/commonTest/kotlin/com/sebastiannarvaez/pokedex/feature/list/PokemonPagingSourceTest.kt

package com.sebastiannarvaez.pokedex.feature.list
 
import androidx.paging.Pager
import androidx.paging.PagingConfig
import androidx.paging.PagingSource
import androidx.paging.testing.asSnapshot
import com.sebastiannarvaez.pokedex.core.AppDispatchers
import com.sebastiannarvaez.pokedex.data.PokemonRepository
import com.sebastiannarvaez.pokedex.data.network.PokeApi
import com.sebastiannarvaez.pokedex.data.network.dto.NamedRefDto
import com.sebastiannarvaez.pokedex.data.network.dto.PokemonDetailDto
import com.sebastiannarvaez.pokedex.data.network.dto.PokemonPageDto
import com.sebastiannarvaez.pokedex.data.network.dto.PokemonRefDto
import com.sebastiannarvaez.pokedex.data.network.dto.TypeSlotDto
import kotlinx.coroutines.CoroutineDispatcher
import kotlinx.coroutines.test.StandardTestDispatcher
import kotlinx.coroutines.test.runTest
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertTrue
 
// Un PokeAPI de mentira con `total` Pokémon llamados «pokemon-1», «pokemon-2»…
// Si `falla` es true, el listado lanza un error, como una red caída.
private class FakePokeApi(private val total: Int, private val falla: Boolean = false) : PokeApi {
 
    override suspend fun page(limit: Int, offset: Int): PokemonPageDto {
        // `error("…")` es una función de Kotlin que lanza una excepción con ese
        // mensaje: aquí hace de «red caída».
        if (falla) error("sin red")
        // Los números de esta página: desde el siguiente al `offset` hasta el último (sin pasar del total).
        val desde = offset + 1
        val hasta = minOf(offset + limit, total)
        return PokemonPageDto(
            count = total,
            results = (desde..hasta).map {
                PokemonRefDto(name = "pokemon-$it", url = "https://pokeapi.co/api/v2/pokemon/$it/")
            },
        )
    }
 
    // Todos los detalles son del tipo normal: aquí el tipo no se prueba.
    override suspend fun detail(id: Int) = PokemonDetailDto(
        id = id,
        name = "pokemon-$id",
        types = listOf(TypeSlotDto(slot = 1, type = NamedRefDto("normal"))),
    )
}
 
// Los tres dispatchers de la app apuntan al de prueba, que obedece al reloj virtual.
private class TestDispatchers(private val d: CoroutineDispatcher) : AppDispatchers {
    override val io = d
    override val default = d
    override val main = d
}
 
class PokemonPagingSourceTest {
 
    // Una fuente de páginas real (la de la app) sobre el repositorio con el doble.
    private fun fuente(total: Int, falla: Boolean = false, scheduler: kotlinx.coroutines.test.TestCoroutineScheduler) =
        PokemonPagingSource(PokemonRepository(FakePokeApi(total, falla), TestDispatchers(StandardTestDispatcher(scheduler))))
}

    @Test
    fun elDesplazamientoAvanzaPaginaAPagina() = runTest {
        // Sin ajustes propios: los valores por defecto de Paging.
        val pager = Pager(
            config = PagingConfig(pageSize = 20),
            pagingSourceFactory = { fuente(total = 100, scheduler = testScheduler) },
        )
 
        val items = pager.flow.asSnapshot { scrollTo(index = 39) }
 
        assertEquals(40, items.size)
    }

java.lang.AssertionError: expected:<40> but was:<60>

    @Test
    fun elDesplazamientoAvanzaPaginaAPagina() = runTest {
        // La misma configuración que usa el ViewModel. Si aquí se pusiera otra, el
        // test estaría probando una app que no existe.
        val pager = Pager(
            config = PagingConfig(
                pageSize = PokemonListViewModel.PAGE_SIZE,
                prefetchDistance = 5,
                enablePlaceholders = false,
            ),
            pagingSourceFactory = { fuente(total = 100, scheduler = testScheduler) },
        )
 
        // `asSnapshot` recorre el flujo como lo haría la pantalla; dentro del bloque
        // se «mira» hasta el elemento 59, el último de la carga inicial (que son 60).
        val items = pager.flow.asSnapshot { scrollTo(index = 59) }
 
        assertEquals("pokemon-1", items.first().name)
        // Al acercarse al final de lo cargado, Paging ha pedido otra página.
        assertTrue(items.size > 60, "no se pidio otra pagina: hay ${items.size}")
        // Y ningún Pokémon está repetido.
        assertEquals(items.size, items.map { it.id }.distinct().size, "hay elementos repetidos")
 
        // Refrescar a mitad de la lista vuelve a empezar desde el primero, y la
        // lista que queda es continua: del 1 al último, sin huecos ni repetidos.
        val tras = pager.flow.asSnapshot {
            scrollTo(index = 59)
            refresh()
        }
        assertEquals((1..tras.size).toList(), tras.map { it.id }, "tras refrescar faltan o sobran Pokémon")
    }

    @Test
    fun laListaSeAcabaCuandoLaPaginaVieneCorta() = runTest {
        val fuente = fuente(total = 25, scheduler = testScheduler)
 
        // Se piden las páginas a mano: la primera (`Refresh`, sin clave) y la
        // siguiente (`Append`, desde el 20). Con argumentos con nombre: la clave,
        // cuántos elementos pedir y si hay huecos reservados.
        val primera = fuente.load(PagingSource.LoadParams.Refresh(key = null, loadSize = 20, placeholdersEnabled = false))
        val segunda = fuente.load(PagingSource.LoadParams.Append(key = 20, loadSize = 20, placeholdersEnabled = false))
 
        // `x as Tipo` dice «trata `x` como un `Tipo`». Si `primera` no fuera una `Page`
        // (por ejemplo, un `Error`), el test se rompería aquí con una excepción de
        // conversión, y eso también es un fallo del test.
        assertEquals(20, (primera as PagingSource.LoadResult.Page).data.size)
        val ultima = segunda as PagingSource.LoadResult.Page
        assertEquals(5, ultima.data.size)
        // `nextKey` a `null` es lo que apaga la petición de la página siguiente.
        assertEquals(null, ultima.nextKey)
    }
 
    @Test
    fun unFalloDeRedLlegaComoErrorYNoComoExcepcion() = runTest {
        val fuente = fuente(total = 60, falla = true, scheduler = testScheduler)
 
        val resultado = fuente.load(PagingSource.LoadParams.Refresh(key = null, loadSize = 20, placeholdersEnabled = false))
 
        // La pantalla necesita un estado de error con botón de reintentar, no una
        // excepción que tumbe la corrutina.
        assertTrue(resultado is PagingSource.LoadResult.Error)
    }