Los tests del repositorio

    private val estado = PagingState<Int, PokemonEntity>(
        pages = emptyList(),
        anchorPosition = null,
        config = PagingConfig(pageSize = PokemonListRepository.PAGE_SIZE),
        leadingPlaceholderCount = 0,
    )

import androidx.paging.RemoteMediator.InitializeAction
import kotlin.time.Duration.Companion.hours

    @Test
    fun alAbrirSinCopiaSePideLaRed() = runTest {
        assertEquals(InitializeAction.LAUNCH_INITIAL_REFRESH, mediador().initialize())
    }
 
    @Test
    fun alAbrirConCopiaRecienteNoSePideLaRed() = runTest {
        mediador().load(LoadType.REFRESH, estado)
        reloj += 1.hours.inWholeMilliseconds
 
        assertEquals(InitializeAction.SKIP_INITIAL_REFRESH, mediador().initialize())
    }
 
    @Test
    fun alAbrirConCopiaCaducadaSeRefresca() = runTest {
        mediador().load(LoadType.REFRESH, estado)
        reloj += PokemonRemoteMediator.CADUCIDAD.inWholeMilliseconds + 1
 
        assertEquals(InitializeAction.LAUNCH_INITIAL_REFRESH, mediador().initialize())
    }

src/jvmTest/kotlin/com/sebastiannarvaez/pokedex/data/PokemonListRepositoryTest.kt

package com.sebastiannarvaez.pokedex.data
 
import androidx.paging.CombinedLoadStates
import androidx.paging.LoadState
import androidx.paging.PagingData
import androidx.paging.PagingDataEvent
import androidx.paging.PagingDataPresenter
import androidx.paging.testing.asSnapshot
import com.sebastiannarvaez.pokedex.data.local.createDatabase
import com.sebastiannarvaez.pokedex.data.local.getDatabaseBuilder
import com.sebastiannarvaez.pokedex.dobles.FakePokeApi
import com.sebastiannarvaez.pokedex.dobles.TestDispatchers
import com.sebastiannarvaez.pokedex.domain.Pokemon
import kotlin.test.AfterTest
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFailsWith
import kotlin.test.assertIs
import kotlin.test.assertTrue
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.collectLatest
import kotlinx.coroutines.flow.filterNotNull
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.launch
import kotlinx.coroutines.test.StandardTestDispatcher
import kotlinx.coroutines.test.TestScope
import kotlinx.coroutines.test.UnconfinedTestDispatcher
import kotlinx.coroutines.test.runTest
import kotlinx.io.IOException
 
/**
 * El repositorio entero, como lo ve la pantalla: un flujo de paginas.
 *
 * `asSnapshot` recorre ese flujo como lo haria la interfaz, con el Pager, el
 * mediador y el PagingSource de Room de verdad. Lo unico de mentira es la red.
 */
@OptIn(ExperimentalCoroutinesApi::class) // UnconfinedTestDispatcher es experimental
class PokemonListRepositoryTest {
 
    private val db = createDatabase(getDatabaseBuilder())
    private var reloj = 1_000_000L
 
    @AfterTest
    fun cerrar() = db.close()
 
    private fun TestScope.repo(falla: Boolean = false) = PokemonListRepository(
        red = PokemonRepository(FakePokeApi(total = 100, falla = falla), TestDispatchers(StandardTestDispatcher(testScheduler))),
        db = db,
        ahora = { reloj },
    )
 
    /**
     * Pinta el flujo como lo haria una pantalla y espera a un estado.
     *
     * `asSnapshot` no sirve aqui: ante un error del mediador lanza la
     * excepcion y no deja ver la lista que sigue en pantalla. Esto es lo mismo
     * que hace el presentador de iOS: un `PagingDataPresenter` que recoge.
     */
    private suspend fun TestScope.mirar(
        flujo: Flow<PagingData<Pokemon>>,
        hasta: (CombinedLoadStates) -> Boolean,
    ): Pair<List<Pokemon>, CombinedLoadStates> {
        val hilo = UnconfinedTestDispatcher(testScheduler)
        val presentador = object : PagingDataPresenter<Pokemon>(mainContext = hilo) {
            override suspend fun presentPagingDataEvent(event: PagingDataEvent<Pokemon>) = Unit
        }
        backgroundScope.launch(hilo) { flujo.collectLatest { presentador.collectFrom(it) } }
        val estados = presentador.loadStateFlow.filterNotNull().first(hasta)
        return presentador.snapshot().items to estados
    }
 
    @Test
    fun laPrimeraVezLaListaLlegaDeLaRedPasandoPorLaBase() = runTest {
        val items = repo().pokemon().asSnapshot()
 
        assertEquals("pokemon-1", items.first().name)
        // Lo que se ve es lo que se guardo: la base tiene al menos esa pagina.
        assertTrue(db.pokemonDao().count() >= items.size)
    }
 
    @Test
    fun sinRedSeVeLoGuardadoYElFalloLlegaDelMediador() = runTest {
        repo().pokemon().asSnapshot()
        val guardados = db.pokemonDao().count()
        // La copia ha caducado: al abrir se intentara refrescar, y fallara.
        reloj += PokemonRemoteMediator.CADUCIDAD.inWholeMilliseconds + 1
 
        val (items, estados) = mirar(repo(falla = true).pokemon()) { it.mediator?.refresh is LoadState.Error }
 
        // La lista sigue ahi, entera: el fallo no vacio la base.
        assertEquals("pokemon-1", items.first().name)
        assertEquals(guardados, db.pokemonDao().count())
        // Y el error es del mediador (la red), no de la fuente (la base), que
        // leyo bien. Es la diferencia que la pantalla usa para avisar.
        assertIs<LoadState.Error>(estados.mediator?.refresh)
        assertIs<LoadState.NotLoading>(estados.source.refresh)
    }
 
    @Test
    fun sinRedYSinNadaGuardadoFalla() = runTest {
        // Lo que antes hacia el PagingSource de red: sin datos, el error llega.
        // FakePokeApi con `falla = true` lanza una IOException, como una red caida.
        assertFailsWith<IOException> { repo(falla = true).pokemon().asSnapshot() }
    }
}

package com.sebastiannarvaez.pokedex.feature.list
 
import androidx.lifecycle.viewModelScope
import androidx.room3.Room
import app.cash.turbine.test
import com.sebastiannarvaez.pokedex.data.PokemonListRepository
import com.sebastiannarvaez.pokedex.data.PokemonRepository
import com.sebastiannarvaez.pokedex.data.local.PokedexDatabase
import com.sebastiannarvaez.pokedex.data.local.PokedexDatabaseConstructor
import com.sebastiannarvaez.pokedex.data.local.createDatabase
import com.sebastiannarvaez.pokedex.dobles.FakePokeApi
import com.sebastiannarvaez.pokedex.dobles.TestDispatchers
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.cancel
import kotlinx.coroutines.job
import kotlinx.coroutines.test.TestCoroutineScheduler
import kotlinx.coroutines.test.UnconfinedTestDispatcher
import kotlinx.coroutines.test.resetMain
import kotlinx.coroutines.test.runTest
import kotlinx.coroutines.test.setMain
import kotlin.test.AfterTest
import kotlin.test.BeforeTest
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertTrue
 
 
/**
 * Vive en `iosTest` porque el presentador solo existe en iOS: es el sustituto
 * de lo que en Android hace `paging-compose`.
 */
@OptIn(ExperimentalCoroutinesApi::class) // UnconfinedTestDispatcher es experimental
class PokemonListPresenterTest {
 
    // Una base en memoria, tambien en iOS: la lista ya no sale de la red sino
    // de aqui. Sin nombre de fichero no hace falta ninguna ruta.
    private val db: PokedexDatabase = createDatabase(
        Room.inMemoryDatabaseBuilder<PokedexDatabase>(factory = PokedexDatabaseConstructor::initialize),
    )
    private var reloj = 1_000_000L
 
    /** Lo que cada test enciende, para apagarlo entero al terminar. */
    private val presentadores = mutableListOf<PokemonListPresenter>()
    private val viewModels = mutableListOf<PokemonListViewModel>()
 
    /**
     * El hilo principal, de prueba.
     *
     * Las paginas se reparten desde `Dispatchers.Main`. Sin este hilo de
     * prueba, el test se queda esperando para siempre (mira la trampa de la
     * leccion) sin decir por que.
     */
    @BeforeTest
    fun instalarElHiloPrincipal() = Dispatchers.setMain(UnconfinedTestDispatcher())
 
    @AfterTest
    fun cerrar() {
        db.close()
        Dispatchers.resetMain()
    }
 
    /**
     * Apaga lo que el test encendio y **espera** a que acabe.
     *
     * - `close()` cierra los presentadores.
     * - `cancel()` cancela el trabajo del ViewModel, como al destruirlo.
     * - `join()` espera a que ese trabajo haya terminado de verdad.
     *
     * Sin la espera, el test cierra la base mientras algo aun la usa y falla
     * de vez en cuando.
     */
    private suspend fun apagar() {
        presentadores.forEach { it.close() }
        viewModels.forEach { it.viewModelScope.cancel() }
        viewModels.forEach { it.viewModelScope.coroutineContext.job.join() }
    }
 
    private fun presentador(total: Int, falla: Boolean, scheduler: TestCoroutineScheduler): PokemonListPresenter {
        // Unconfined y no Standard: el presentador de Paging encadena varias
        // corrutinas antes de publicar el primer estado, y con el dispatcher
        // estandar hay que adelantar el reloj a mano en cada eslabon. Con el
        // no confinado, cada paso corre en cuanto puede.
        val d = TestDispatchers(UnconfinedTestDispatcher(scheduler))
        val red = PokemonRepository(FakePokeApi(total, falla), d)
        val lista = PokemonListRepository(red, db) { reloj }
        val viewModel = PokemonListViewModel(lista).also { viewModels += it }
        return PokemonListPresenter(viewModel, d).also { presentadores += it }
    }
 
    @Test
    fun laPrimeraPaginaLlegaAlEstado() = runTest {
        val p = presentador(total = 60, falla = false, scheduler = testScheduler)
 
        p.state.test {
            // El primer valor puede traer ya la pagina: con el dispatcher no
            // confinado, Paging corre antes de que el test se suscriba. Por eso
            // se espera al primer estado con datos en vez de contar emisiones.
            var estado = awaitItem()
            while (estado.items.isEmpty()) estado = awaitItem()
 
            // No se afirma un numero exacto de elementos: con el dispatcher no
            // confinado, Paging encadena las cargas que puede antes de que el
            // test mire, y ese numero depende del planificador, no de la app.
            // Lo que si es estable es que empiece por el primero y que no haya
            // repetidos.
            assertEquals("pokemon-1", estado.items.first().name)
            assertEquals(estado.items.size, estado.items.map { it.id }.distinct().size, "hay repetidos")
            cancelAndIgnoreRemainingEvents()
        }
        apagar()
    }
 
    @Test
    fun sinRedNiNadaGuardadoLlegaUnErrorQueSePuedeReintentar() = runTest {
        val p = presentador(total = 60, falla = true, scheduler = testScheduler)
 
        p.state.test {
            var estado = awaitItem()
            while (estado.error == null) estado = awaitItem()
 
            assertTrue(estado.items.isEmpty())
            // El `while` de arriba solo termina cuando `error` ya no es `null`,
            // y Kotlin lo sabe: por eso aqui se lee sin `!!` ni `?`.
            assertTrue(estado.error.sePuedeReintentar, "el error deberia ofrecer reintento")
            cancelAndIgnoreRemainingEvents()
        }
        apagar()
    }
}

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