Casos de uso: cuándo sí y cuándo sobran

package com.sebastiannarvaez.marcador.feature.cronica.domain
 
import com.sebastiannarvaez.marcador.core.domain.resumen
import com.sebastiannarvaez.marcador.feature.partidos.domain.PartidosRepository
import com.sebastiannarvaez.marcador.torneo.Gol
import com.sebastiannarvaez.marcador.torneo.intentar
import javax.inject.Inject
 
// CASO DE USO CON DOS REPOSITORIOS. Aqui SI vale la pena:
//   - hay una REGLA de negocio: como se escribe una cronica (titulo = el resumen del
//     partido; texto = una linea por gol, en orden, o «Sin goles»);
//   - JUNTA dos repositorios: los partidos (Room) y las cronicas (la red);
//   - la regla se prueba sin pantalla (PublicarCronicaTest).
// Direccion: ViewModel -> caso de uso -> repositorios. Nunca al reves.
//
// Contraejemplo: la pantalla de arbitros llama a ArbitrosRepository DIRECTO. Un
// `ObtenerArbitros` que solo reenviara `observarArbitros()` seria pura ceremonia.
class PublicarCronica @Inject constructor(
    private val partidos: PartidosRepository,
    private val cronicas: CronicasRepository,
) {
    suspend operator fun invoke(partidoId: Int): Result<CronicaPublicada> = intentar {
        val partido = partidos.partido(partidoId) ?: error("No existe el partido $partidoId")
        val titulo = partido.resumen()
        val goles = partido.eventos.filterIsInstance<Gol>().sortedBy { it.minuto }
        val texto = if (goles.isEmpty()) "Sin goles" else goles.joinToString("\n") { "${it.minuto}' ${it.jugador.nombre} (${it.equipo.nombre})" }
        // getOrThrow: si la red fallo, el FalloDeRed sale tal cual en el Result de fuera.
        CronicaPublicada(cronicas.publicar(titulo, texto).getOrThrow(), titulo, texto)
    }
}

package com.sebastiannarvaez.marcador.feature.cronica.ui
 
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.sebastiannarvaez.marcador.core.ui.mensajeParaElUsuario
import com.sebastiannarvaez.marcador.feature.cronica.domain.PublicarCronica
import dagger.assisted.Assisted
import dagger.assisted.AssistedFactory
import dagger.assisted.AssistedInject
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch
 
// Publica la cronica de un partido. La regla («como se escribe una cronica») vive en el
// caso de uso; el ViewModel solo traduce su resultado a estado de pantalla.
// INYECCION ASISTIDA, como en PartidoViewModel: Hilt pone lo que sabe construir; el id
// del partido lo pone la pantalla (sale de la CronicaKey). @Assisted marca el que llega de fuera.
@HiltViewModel(assistedFactory = CronicaViewModel.Fabrica::class)
class CronicaViewModel @AssistedInject constructor(
    private val publicarCronica: PublicarCronica,
    @Assisted private val partidoId: Int,
) : ViewModel() {
 
    // La fabrica que Hilt ESCRIBE: solo se declara la funcion con lo que falta.
    @AssistedFactory
    interface Fabrica {
        fun crear(partidoId: Int): CronicaViewModel
    }
 
    private val _uiState = MutableStateFlow(CronicaUiState(partidoId))
    val uiState: StateFlow<CronicaUiState> = _uiState.asStateFlow()
 
    fun publicar() {
        if (_uiState.value.publicando) return
        _uiState.update { it.copy(publicando = true, error = null) }
        viewModelScope.launch {
            val resultado = publicarCronica(partidoId)
            _uiState.update { estado ->
                resultado.fold(
                    onSuccess = { estado.copy(publicando = false, publicada = it) },
                    onFailure = { estado.copy(publicando = false, error = it.mensajeParaElUsuario()) },
                )
            }
        }
    }
}

import com.sebastiannarvaez.marcador.feature.cronica.domain.CronicasRepository

// El repositorio de cronicas, de mentira: apunta lo publicado y responde con el 101.
class FakeCronicasRepository(var fallo: Exception? = null) : CronicasRepository {
    // Pair<String, String> = una pareja de dos textos (título, texto); `titulo to texto` la crea.
    val publicadas = mutableListOf<Pair<String, String>>()
 
    override suspend fun publicar(titulo: String, texto: String): Result<Int> {
        fallo?.let { return Result.failure(it) }
        publicadas += titulo to texto
        return Result.success(101)
    }
}

package com.sebastiannarvaez.marcador.feature.cronica.domain
 
import com.sebastiannarvaez.marcador.core.FakeCronicasRepository
import com.sebastiannarvaez.marcador.core.FakePartidosRepository
import com.sebastiannarvaez.marcador.core.partidoConGoles
import com.sebastiannarvaez.marcador.feature.partidos.domain.PartidoDeLista
import kotlinx.coroutines.test.runTest
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertTrue
 
// La regla de la cronica, probada SIN pantalla y SIN red: dos repositorios falsos.
class PublicarCronicaTest {
 
    @Test
    fun escribeElTituloYUnaLineaPorGol() = runTest {
        // partidoConGoles (Falsos.kt): Rayo FC 2-1 Toros, goles al 15, 30 y 60.
        val cronicas = FakeCronicasRepository()
        val publicar = PublicarCronica(FakePartidosRepository(listOf(PartidoDeLista(1, partidoConGoles()))), cronicas)
 
        val resultado = publicar(1)    // publicar(1) llama al caso de uso, como una función
 
        val texto = "15' Ana (Rayo FC)\n30' Iván (Toros)\n60' Ana (Rayo FC)"
        assertEquals(Result.success(CronicaPublicada(101, "Rayo FC 2-1 Toros", texto)), resultado)
        assertEquals(listOf("Rayo FC 2-1 Toros" to texto), cronicas.publicadas)
    }
 
    @Test
    fun unPartidoQueNoExisteFallaYNoPublicaNada() = runTest {
        val cronicas = FakeCronicasRepository()
        // Dos pasos en una línea: PublicarCronica(…) crea el caso de uso y el (7) lo llama.
        val resultado = PublicarCronica(FakePartidosRepository(), cronicas)(7)
 
        assertEquals("No existe el partido 7", resultado.exceptionOrNull()?.message)
        assertTrue(cronicas.publicadas.isEmpty())
    }
}