Quitar con deshacer

import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.withTimeoutOrNull
 
fun main() = runBlocking {
    // Dos buzones para un aviso. El primero reparte el aviso a quien esté
    // mirando EN ESE MOMENTO; el segundo lo guarda hasta que alguien lo borre.
    val comoEvento = MutableSharedFlow<String>()
    val comoEstado = MutableStateFlow<String?>(null)
 
    // Se quita un producto justo cuando la pantalla está girando: nadie mira.
    comoEvento.emit("Pan quitado")
    comoEstado.value = "Pan quitado"
 
    // Llega la pantalla nueva y mira los dos buzones. first() espera al primer
    // valor que llegue y lo devuelve; withTimeoutOrNull(100) se rinde a los
    // 100 ms y da null si no llegó ninguno.
    val enElEvento = withTimeoutOrNull(100) { comoEvento.first() }
    println("evento: $enElEvento")
    println("estado: ${comoEstado.value}")
 
    // La pantalla enseña el aviso y le dice al buzón que ya lo vio.
    comoEstado.value = null
    println("estado, ya visto: ${comoEstado.value}")
}

evento: null
estado: Pan quitado
estado, ya visto: null

    /** La fila entera, o null si no esta. La usa «deshacer» para devolverla tal cual. */
    @Query("SELECT * FROM favorite WHERE pokemonId = :pokemonId")
    suspend fun find(pokemonId: Int): FavoriteEntity?

    /**
     * Quita un favorito y devuelve su fila tal como estaba, con su fecha, para
     * poder ponerla igual si el usuario se arrepiente. null si no estaba.
     */
    suspend fun quitar(id: Int): FavoriteEntity? = withContext(dispatchers.io) {
        dao.find(id)?.also { dao.remove(id) }
    }
 
    /** Vuelve a poner una fila quitada. Con su fecha de antes, recupera su sitio en la lista. */
    suspend fun restaurar(fila: FavoriteEntity) = withContext(dispatchers.io) { dao.add(fila) }

package com.sebastiannarvaez.pokedex.feature.favorites
 
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.sebastiannarvaez.pokedex.data.FavoritesRepository
import com.sebastiannarvaez.pokedex.data.local.FavoriteEntity
import com.sebastiannarvaez.pokedex.domain.FavoritePokemon
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.launch
 
data class FavoritesUiState(
    val favoritos: List<FavoritePokemon> = emptyList(),
    val cargando: Boolean = true,
    /**
     * El favorito que se acaba de quitar, mientras la pantalla ofrece
     * deshacerlo. Es un mensaje que se consume: la pantalla lo enseña y avisa
     * con `deshacer()` o con `mensajeMostrado()`. null: no hay nada que enseñar.
     */
    val quitado: FavoritePokemon? = null,
) {
    val vacia: Boolean get() = !cargando && favoritos.isEmpty()
}
 
class FavoritesViewModel internal constructor(
    private val repository: FavoritesRepository,
) : ViewModel() {
 
    // El mensaje vive en el ViewModel, no en la base: es de esta pantalla.
    private val quitado = MutableStateFlow<FavoritePokemon?>(null)
    // La fila tal como estaba, para devolverla con su fecha. No sale del ViewModel.
    private var filaQuitada: FavoriteEntity? = null
 
    val uiState: StateFlow<FavoritesUiState> =
        combine(repository.observeFavorites(), quitado) { favoritos, q ->
            FavoritesUiState(favoritos = favoritos, cargando = false, quitado = q)
        }.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) }
    }
 
    /** Deslizar una fila: la quita y deja el mensaje con su «Deshacer». */
    fun quitar(favorito: FavoritePokemon) {
        viewModelScope.launch {
            filaQuitada = repository.quitar(favorito.id) ?: return@launch
            quitado.value = favorito
        }
    }
 
    /** La accion del mensaje: lo devuelve a su sitio y consume el mensaje. */
    fun deshacer() {
        val fila = filaQuitada ?: return
        filaQuitada = null
        quitado.value = null
        viewModelScope.launch { repository.restaurar(fila) }
    }
 
    /** La pantalla ya lo enseño (y se fue sin deshacer): el mensaje se consume. */
    fun mensajeMostrado() {
        filaQuitada = null
        quitado.value = null
    }
 
    fun vaciar() {
        viewModelScope.launch { repository.clear() }
    }
}

    @BeforeTest
    fun instalarElHiloPrincipal() = Dispatchers.setMain(StandardTestDispatcher())
 
    @AfterTest
    fun limpiar() {
        Dispatchers.resetMain()
        db.close()
    }

    /** Room avisa cuando le da tiempo: se esperan estados hasta el que se busca. */
    private suspend fun ReceiveTurbine<FavoritesUiState>.hasta(condicion: (FavoritesUiState) -> Boolean): FavoritesUiState {
        var estado = awaitItem()
        // Mientras el estado no cumpla la condición, pide el siguiente.
        while (!condicion(estado)) {
            estado = awaitItem()
        }
        return estado
    }
 
    @Test
    fun quitarDejaElMensajeYDeshacerLoDevuelveASuSitio() = runTest {
        val repo = repo(testScheduler)
        reloj = 1_000; repo.toggle(1, "bulbasaur")
        reloj = 2_000; repo.toggle(4, "charmander")
        reloj = 3_000; repo.toggle(25, "pikachu")
        val vm = FavoritesViewModel(repo)
 
        vm.uiState.test {
            val charmander = hasta { !it.cargando }.favoritos[1]
            reloj = 9_000 // si deshacer usara la hora de ahora, charmander subiria arriba
 
            vm.quitar(charmander)
            // Room avisa de la fila borrada un instante despues: se espera a las dos cosas.
            val conMensaje = hasta { it.quitado != null && it.favoritos.size == 2 }
            assertEquals(charmander, conMensaje.quitado)
            assertEquals(listOf("pikachu", "bulbasaur"), conMensaje.favoritos.map { it.name })
 
            vm.deshacer()
            val deshecho = hasta { it.quitado == null && it.favoritos.size == 3 }
            assertEquals(listOf("pikachu", "charmander", "bulbasaur"), deshecho.favoritos.map { it.name })
            cancelAndIgnoreRemainingEvents()
        }
    }
 
    @Test
    fun mensajeMostradoLoConsumeYElFavoritoSigueQuitado() = runTest {
        val repo = repo(testScheduler)
        repo.toggle(25, "pikachu")
        val vm = FavoritesViewModel(repo)
 
        vm.uiState.test {
            val pikachu = hasta { !it.cargando }.favoritos.single()
            vm.quitar(pikachu)
            hasta { it.quitado != null && it.vacia }
 
            vm.mensajeMostrado()
            val consumido = hasta { it.quitado == null }
            assertTrue(consumido.vacia)
            // Ya no hay nada que deshacer: el gesto llega tarde y no hace nada.
            vm.deshacer()
            expectNoEvents()
            cancelAndIgnoreRemainingEvents()
        }
        // quitar devuelve null si la fila ya no esta: asi se comprueba que sigue quitada.
        assertNull(repo.quitar(25))
    }

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

expected:<[pikachu, charmander, bulbasaur]> but was:<[charmander, pikachu, bulbasaur]>