Favoritos en el núcleo

    // Room genera un `expect object` para construir la base de datos, y las
    // clases expect/actual siguen en Beta. El aviso lo pide el propio
    // compilador: sin la bandera, cada compilacion escupe la misma linea.
    compilerOptions {
        freeCompilerArgs.add("-Xexpect-actual-classes")
    }

package com.sebastiannarvaez.pokedex.domain
 
/**
 * Un favorito, ya en lenguaje de la app.
 *
 * Tiene lo justo para pintar una fila **sin red**: numero, nombre y la
 * ilustracion, que se construye del numero.
 */
data class FavoritePokemon(val id: Int, val name: String) {
    val artworkUrl: String
        get() = "https://raw.githubusercontent.com/PokeAPI/sprites/master/sprites/pokemon/other/official-artwork/$id.png"
}

package com.sebastiannarvaez.pokedex.data
 
import com.sebastiannarvaez.pokedex.core.AppDispatchers
import com.sebastiannarvaez.pokedex.data.local.FavoriteDao
import com.sebastiannarvaez.pokedex.data.local.FavoriteEntity
import com.sebastiannarvaez.pokedex.domain.FavoritePokemon
import kotlin.time.Clock
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.withContext
 
/**
 * Los favoritos, traducidos de fila a dominio.
 *
 * El reloj se inyecta en vez de llamar a `Clock.System` por dentro: asi un test
 * puede fijar la hora y comprobar el orden sin dormir.
 */
internal class FavoritesRepository(
    private val dao: FavoriteDao,
    private val dispatchers: AppDispatchers,
    // El reloj por defecto es el real; un test pasa el suyo.
    private val ahora: () -> Long = { Clock.System.now().toEpochMilliseconds() },
) {
}

    suspend fun toggle(id: Int, name: String): Boolean = withContext(dispatchers.io) {
        // Un bloque `{ … }` vale lo que valga su última línea, como el `if` de
        // «Condiciones: if y when»: aqui, `false` en la primera rama y `true` en la segunda.
        if (dao.isFavorite(id)) {
            dao.remove(id)
            false
        } else {
            dao.add(FavoriteEntity(pokemonId = id, name = name, addedAt = ahora()))
            true
        }
    }

    fun observeFavorites(): Flow<List<FavoritePokemon>> =
        dao.observeAll().map { filas -> filas.map { FavoritePokemon(it.pokemonId, it.name) } }
 
    /**
     * Solo los identificadores, como conjunto.
     *
     * Es lo que la lista necesita para pintar el corazon, y va aparte a
     * proposito: combinarlo dentro del `PagingData` obligaria a reemitir la
     * pagina entera cada vez que se marca uno, con su parpadeo y su salto de
     * scroll. Un `Set` responde «¿esta este numero?» sin recorrerse entero.
     */
    fun observeFavoriteIds(): Flow<Set<Int>> = dao.observeIds().map { it.toSet() }

    suspend fun clear() = withContext(dispatchers.io) { dao.clear() }

src/commonMain/kotlin/com/sebastiannarvaez/pokedex/feature/favorites/FavoritesViewModel.kt

package com.sebastiannarvaez.pokedex.feature.favorites
 
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.sebastiannarvaez.pokedex.data.FavoritesRepository
import com.sebastiannarvaez.pokedex.domain.FavoritePokemon
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.launch

data class FavoritesUiState(
    val favoritos: List<FavoritePokemon> = emptyList(),
    val cargando: Boolean = true,
) {
    val vacia: Boolean get() = !cargando && favoritos.isEmpty()
}

class FavoritesViewModel internal constructor(
    private val repository: FavoritesRepository,
) : ViewModel() {
 
    val uiState: StateFlow<FavoritesUiState> = repository.observeFavorites()
        .map { FavoritesUiState(favoritos = it, cargando = false) }
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), FavoritesUiState())
 
    /** Los identificadores, para que la lista pinte el corazon sin recargarse. */
    val favoriteIds: StateFlow<Set<Int>> = repository.observeFavoriteIds()
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), emptySet())
 
    fun toggle(id: Int, name: String) {
        viewModelScope.launch { repository.toggle(id, name) }
    }
 
    fun vaciar() {
        viewModelScope.launch { repository.clear() }
    }
}

    single { FavoritesRepository(get(), get()) }

    viewModelOf(::FavoritesViewModel)

package com.sebastiannarvaez.pokedex.feature.favorites
 
import app.cash.turbine.test
import com.sebastiannarvaez.pokedex.data.FavoritesRepository
import com.sebastiannarvaez.pokedex.data.local.createDatabase
import com.sebastiannarvaez.pokedex.data.local.getDatabaseBuilder
import com.sebastiannarvaez.pokedex.dobles.TestDispatchers
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.test.StandardTestDispatcher
import kotlinx.coroutines.test.runTest
import kotlin.test.AfterTest
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFalse
import kotlin.test.assertTrue
 
@OptIn(ExperimentalCoroutinesApi::class)
class FavoritesTest {
 
    private val db = createDatabase(getDatabaseBuilder())
    private var reloj = 1_000L
 
    // Se ejecuta después de cada test: cierra la base, como en el test del DAO.
    @AfterTest
    fun limpiar() = db.close()
 
    // El repositorio de cada test: la base de arriba, un dispatcher que comparte el
    // reloj virtual del test y, en la lambda final, el reloj de mentira. Kotlin deja
    // sacar la ultima lambda fuera de los parentesis: esto es lo mismo que
    // `FavoritesRepository(dao, dispatchers, ahora = { reloj })`, asi que `ahora()`
    // devuelve cada vez lo que valga `reloj` en ese momento.
    private fun repo(scheduler: kotlinx.coroutines.test.TestCoroutineScheduler) =
        FavoritesRepository(db.favoriteDao(), TestDispatchers(StandardTestDispatcher(scheduler))) { reloj }
 
    @Test
    fun marcarYDesmarcarDevuelveElEstadoNuevo() = runTest {
        val repo = repo(testScheduler)
 
        assertTrue(repo.toggle(25, "pikachu"), "marcar deberia devolver true")
        assertFalse(repo.toggle(25, "pikachu"), "desmarcar deberia devolver false")
    }
 
    @Test
    fun losIdentificadoresLleganComoConjunto() = runTest {
        val repo = repo(testScheduler)
 
        repo.observeFavoriteIds().test {
            assertEquals(emptySet(), awaitItem())
            repo.toggle(25, "pikachu")
            assertEquals(setOf(25), awaitItem())
            repo.toggle(1, "bulbasaur")
            assertEquals(setOf(25, 1), awaitItem())   // en un Set el orden no cuenta
            cancelAndIgnoreRemainingEvents()
        }
    }
 
    @Test
    fun elRelojInyectadoOrdenaLaLista() = runTest {
        val repo = repo(testScheduler)
 
        // El `;` separa dos ordenes en la misma linea: se fija la hora y se marca.
        reloj = 1_000; repo.toggle(1, "bulbasaur")
        reloj = 3_000; repo.toggle(25, "pikachu")
        reloj = 2_000; repo.toggle(4, "charmander")
 
        repo.observeFavorites().test {
            assertEquals(listOf("pikachu", "charmander", "bulbasaur"), awaitItem().map { it.name })
            cancelAndIgnoreRemainingEvents()
        }
    }
 
    @Test
    fun elFavoritoSirveSinRed() = runTest {
        val repo = repo(testScheduler)
        repo.toggle(25, "pikachu")
 
        repo.observeFavorites().test {
            // single() devuelve el unico elemento de la lista (y falla si hay 0 o varios).
            val favorito = awaitItem().single()
            // Nombre e ilustracion sin pedir nada: abrir favoritos en el metro
            // tiene que funcionar.
            assertEquals("pikachu", favorito.name)
            assertTrue(favorito.artworkUrl.endsWith("/25.png"))
            cancelAndIgnoreRemainingEvents()
        }
    }
}

./gradlew :shared:jvmTest --tests "*FavoritesTest*"