Avisos con pruebas: que la app se pruebe sola

git clone https://github.com/rpversontec/practica-11-avisos-con-pruebas.git
cd practica-11-avisos-con-pruebas

[versions]
junit = "4.13.2"

[libraries]
junit = { group = "junit", name = "junit", version.ref = "junit" }

    // Pruebas locales (src/test): corren en la JVM de tu computadora, sin emulador.
    testImplementation(libs.junit)

package mx.tec.avisos.domain

import org.junit.Assert.assertFalse
import org.junit.Assert.assertTrue
import org.junit.Test

/**
 * Las reglas de un aviso, en sus orillas. Un validador casi nunca falla en el
 * medio («Examen parcial»): falla en el 2 contra el 3, en el 60 contra el 61,
 * y en lo que parece texto pero son puros espacios.
 */
class AvisoValidatorTest {

    @Test
    fun un_titulo_de_3_y_uno_de_60_caracteres_son_validos() {
        assertTrue(AvisoValidator.tituloValido("Abc"))
        assertTrue(AvisoValidator.tituloValido("a".repeat(60)))
    }

    @Test
    fun un_titulo_de_2_y_uno_de_61_caracteres_no_son_validos() {
        assertFalse(AvisoValidator.tituloValido("Ab"))
        assertFalse(AvisoValidator.tituloValido("a".repeat(61)))
    }

    @Test
    fun los_espacios_de_las_orillas_no_cuentan() {
        assertFalse(AvisoValidator.tituloValido("     "))
        assertFalse(AvisoValidator.tituloValido("  Ab  "))
    }

    @Test
    fun sin_un_cuerpo_valido_no_se_puede_publicar() {
        assertFalse(AvisoValidator.esValido("Examen parcial", "corto"))
        assertTrue(AvisoValidator.esValido("Examen parcial", "El jueves a las 10:00."))
    }
}

package mx.tec.avisos.ui.components

import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertTrue
import org.junit.Test

/**
 * `tiempoRelativo` recibe `ahora` como parámetro, y por eso se puede probar.
 * Con `System.currentTimeMillis()` adentro, la misma prueba daría otro
 * resultado cada minuto.
 */
class FormatoTest {

    private val publicado = "2026-10-07 15:00:00"
    private val instante = instanteDe(publicado)!!

    private fun despuesDe(minutos: Long): Long = instante + minutos * 60_000

    @Test
    fun recien_publicado_dice_ahora() {
        assertEquals("ahora", tiempoRelativo(publicado, despuesDe(0)))
    }

    @Test
    fun a_los_12_minutos_dice_hace_12_min() {
        assertEquals("hace 12 min", tiempoRelativo(publicado, despuesDe(12)))
    }

    @Test
    fun a_los_59_minutos_todavia_son_minutos_y_a_los_60_ya_es_una_hora() {
        assertEquals("hace 59 min", tiempoRelativo(publicado, despuesDe(59)))
        assertEquals("hace 1 h", tiempoRelativo(publicado, despuesDe(60)))
    }

    @Test
    fun una_fecha_que_no_se_entiende_no_truena() {
        assertEquals("ahora", tiempoRelativo("ayer a las tres", despuesDe(5)))
    }

    @Test
    fun es_nuevo_hasta_un_minuto_antes_de_cumplir_24_horas() {
        assertTrue(esReciente(publicado, despuesDe(24 * 60 - 1)))
        assertFalse(esReciente(publicado, despuesDe(24 * 60)))
    }
}

package mx.tec.avisos.data.remote

import mx.tec.avisos.domain.Rol
import org.junit.Assert.assertEquals
import org.junit.Assert.assertNull
import org.junit.Test

/** Lo que llega del servidor, traducido a lo que la app usa. */
class MappersTest {

    @Test
    fun la_sesion_vence_cuando_dijo_el_servidor() {
        val tokens = TokensDto(accessToken = "a", refreshToken = "r", expiresIn = 300, usuario = "ana", rol = "profesor")

        val sesion = tokens.toSesion(ahora = 1_000)

        assertEquals(1_300L, sesion.expiraEn)
        assertEquals(Rol.PROFESOR, sesion.rol)
    }

    @Test
    fun un_rol_desconocido_es_alumno() {
        val tokens = TokensDto(accessToken = "a", refreshToken = "r", expiresIn = 300, usuario = "ana", rol = "director")

        assertEquals(Rol.ALUMNO, tokens.toSesion(ahora = 0).rol)
    }

    @Test
    fun la_clave_de_la_imagen_se_vuelve_una_direccion_del_servidor() {
        val dto = AvisoDto(id = 1, titulo = "Feria", cuerpo = "El viernes.", autor = "ana", createdAt = "2026-10-07 15:00:00", imagen = "abc.jpg")

        assertEquals("${Network.BASE_URL}imagenes/abc.jpg", dto.toDomain().imagenUrl)
    }

    @Test
    fun sin_imagen_no_hay_direccion() {
        val dto = AvisoDto(id = 1, titulo = "Feria", cuerpo = "El viernes.", autor = "ana", createdAt = "2026-10-07 15:00:00")

        assertNull(dto.toDomain().imagenUrl)
    }
}

[versions]
coroutinesTest = "1.10.2"
androidxTestExt = "1.3.0"
androidxTestRunner = "1.7.0"

[libraries]
kotlinx-coroutines-test = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-test", version.ref = "coroutinesTest" }
androidx-test-ext-junit = { group = "androidx.test.ext", name = "junit", version.ref = "androidxTestExt" }
androidx-test-runner = { group = "androidx.test", name = "runner", version.ref = "androidxTestRunner" }

        // Quién corre las pruebas instrumentadas (las de src/androidTest) en el emulador.
        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"

    // Pruebas instrumentadas (src/androidTest): corren en el emulador, con Android de verdad.
    androidTestImplementation(libs.androidx.test.ext.junit)
    androidTestImplementation(libs.androidx.test.runner)
    androidTestImplementation(libs.kotlinx.coroutines.test)

package mx.tec.avisos

import kotlinx.coroutines.CompletableDeferred
import mx.tec.avisos.data.remote.AvisoDto
import mx.tec.avisos.data.remote.AvisosApi
import mx.tec.avisos.data.remote.Credenciales
import mx.tec.avisos.data.remote.ImagenDto
import mx.tec.avisos.data.remote.MeDto
import mx.tec.avisos.data.remote.NuevoAvisoBody
import mx.tec.avisos.data.remote.RefreshBody
import mx.tec.avisos.data.remote.TokensDto
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.MultipartBody
import okhttp3.ResponseBody.Companion.toResponseBody
import retrofit2.HttpException
import retrofit2.Response

/**
 * Un servidor de mentira. No hay red: responde al instante y anota todo lo que
 * la app le pidió, en orden, para que la prueba pueda preguntar «¿qué hizo?».
 *
 * Es posible porque `AvisosApi` es una interfaz: la app depende de lo que la
 * API promete, no de Retrofit. Es la misma idea de la Práctica 9.
 */
class FakeAvisosApi : AvisosApi {

    /** Lo que la app pidió, en orden: "subirImagen", "crearAviso". */
    val llamadas = mutableListOf<String>()

    /** Cada aviso que la app intentó crear, tal como lo mandó. */
    val avisosCreados = mutableListOf<NuevoAvisoBody>()

    /** Si no es null, crearAviso responde con este error en vez de 201. */
    var errorAlCrear: HttpException? = null

    /** Si no es null, crearAviso se queda esperando aquí: la app queda «a media petición». */
    var compuerta: CompletableDeferred<Unit>? = null

    override suspend fun subirImagen(archivo: MultipartBody.Part): ImagenDto {
        llamadas += "subirImagen"
        return ImagenDto(id = "abc.jpg", tipo = "image/jpeg", bytes = 1234)
    }

    override suspend fun crearAviso(body: NuevoAvisoBody): AvisoDto {
        llamadas += "crearAviso"
        avisosCreados += body
        compuerta?.await()
        errorAlCrear?.let { throw it }
        return AvisoDto(
            id = avisosCreados.size,
            titulo = body.titulo,
            cuerpo = body.cuerpo,
            autor = "ana",
            createdAt = "2026-10-07 15:00:00",
            imagen = body.imagen
        )
    }

    // Lo que estas pruebas no usan. Si algo lo llama, que truene: así se nota.
    override suspend fun register(body: Credenciales): TokensDto = error("no se usa en estas pruebas")
    override suspend fun login(body: Credenciales): TokensDto = error("no se usa en estas pruebas")
    override suspend fun refresh(body: RefreshBody): TokensDto = error("no se usa en estas pruebas")
    override suspend fun logout(body: RefreshBody) = error("no se usa en estas pruebas")
    override suspend fun me(): MeDto = error("no se usa en estas pruebas")
    override suspend fun getAvisos(desde: Int): List<AvisoDto> = error("no se usa en estas pruebas")
    override suspend fun borrarAviso(id: Int): Response<Unit> = error("no se usa en estas pruebas")
}

/** Un error como los que manda el servidor: código y cuerpo `{ "error": … }`. */
fun errorDelServidor(codigo: Int, mensaje: String): HttpException =
    HttpException(
        Response.error<Any>(codigo, """{"error":"$mensaje"}""".toResponseBody("application/json".toMediaType()))
    )

package mx.tec.avisos

import android.content.Context
import android.graphics.Bitmap
import android.graphics.Color
import android.net.Uri
import java.io.File

/**
 * Una foto de verdad, escrita en el caché de la app, del tamaño que la prueba pida.
 * El compresor la abre igual que abriría una de la galería: por su Uri.
 */
fun fotoDePrueba(contexto: Context, ancho: Int, alto: Int): Uri {
    val bitmap = Bitmap.createBitmap(ancho, alto, Bitmap.Config.ARGB_8888).apply { eraseColor(Color.rgb(14, 92, 74)) }
    val archivo = File(contexto.cacheDir, "prueba-${ancho}x$alto.jpg")
    archivo.outputStream().use { bitmap.compress(Bitmap.CompressFormat.JPEG, 90, it) }
    bitmap.recycle()
    return Uri.fromFile(archivo)
}

package mx.tec.avisos.ui.state

import androidx.lifecycle.SavedStateHandle
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.platform.app.InstrumentationRegistry
import kotlinx.coroutines.CompletableDeferred
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.test.UnconfinedTestDispatcher
import kotlinx.coroutines.test.resetMain
import kotlinx.coroutines.test.setMain
import mx.tec.avisos.FakeAvisosApi
import mx.tec.avisos.data.AvisosRepository
import mx.tec.avisos.data.ImagenesRepository
import mx.tec.avisos.data.imagenes.CompresorDeImagen
import mx.tec.avisos.data.imagenes.FotosTemporales
import mx.tec.avisos.data.remote.AvisosStream
import mx.tec.avisos.errorDelServidor
import mx.tec.avisos.fotoDePrueba
import okhttp3.OkHttpClient
import org.junit.After
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertNull
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith

/**
 * El ViewModel de publicar, armado a mano con un servidor de mentira.
 *
 * Corre en el emulador porque el compresor y las fotos temporales necesitan un
 * Context de verdad. Pero no hay red, ni pantalla, ni Hilt: las piezas se
 * construyen aquí, y por eso se pueden cambiar por las de mentira.
 */
@OptIn(ExperimentalCoroutinesApi::class)
@RunWith(AndroidJUnit4::class)
class PublicarViewModelTest {

    private val contexto = InstrumentationRegistry.getInstrumentation().targetContext
    private val api = FakeAvisosApi()

    // viewModelScope corre en Dispatchers.Main. En una prueba no hay pantalla que lo
    // atienda: se cambia por uno que ejecuta todo en cuanto se pide.
    @Before
    fun cambiarMain() {
        Dispatchers.setMain(UnconfinedTestDispatcher())
    }

    @After
    fun restaurarMain() {
        Dispatchers.resetMain()
    }

    private fun nuevoViewModel(guardado: SavedStateHandle = SavedStateHandle()) = PublicarViewModel(
        avisos = AvisosRepository(api, AvisosStream(OkHttpClient())),
        imagenes = ImagenesRepository(api, CompresorDeImagen(contexto)),
        fotos = FotosTemporales(contexto),
        guardado = guardado
    )

    private fun PublicarViewModel.escribirUnAvisoValido() {
        onTituloChange("Examen parcial")
        onCuerpoChange("El jueves a las 10:00 en el salón de siempre.")
    }

    /** Con imagen, el compresor trabaja en otro hilo: se espera a que el ViewModel termine. */
    private fun PublicarViewModel.esperarQueTermine() {
        val limite = System.currentTimeMillis() + 10_000
        while (uiState.enviando && System.currentTimeMillis() < limite) Thread.sleep(50)
        assertFalse("El ViewModel no terminó en 10 s", uiState.enviando)
    }

    @Test
    fun sin_imagen_se_hace_una_sola_peticion() {
        val viewModel = nuevoViewModel()
        viewModel.escribirUnAvisoValido()
        var publicado = false

        viewModel.publicar { publicado = true }

        assertEquals(true, publicado)
        assertEquals(listOf("crearAviso"), api.llamadas)
        assertNull(api.avisosCreados.single().imagen)
    }

    @Test
    fun con_imagen_primero_sube_y_despues_publica_con_la_clave() {
        val viewModel = nuevoViewModel()
        viewModel.escribirUnAvisoValido()
        viewModel.onImagenElegida(fotoDePrueba(contexto, 800, 600))

        viewModel.publicar { }
        viewModel.esperarQueTermine()

        assertEquals(listOf("subirImagen", "crearAviso"), api.llamadas)
        assertEquals("abc.jpg", api.avisosCreados.single().imagen)
    }

    @Test
    fun tocar_publicar_dos_veces_manda_un_solo_aviso() {
        val viewModel = nuevoViewModel()
        viewModel.escribirUnAvisoValido()
        api.compuerta = CompletableDeferred()   // el primer envío se queda «en el aire»

        viewModel.publicar { }
        viewModel.publicar { }
        api.compuerta?.complete(Unit)

        assertEquals(1, api.avisosCreados.size)
    }

    @Test
    fun si_el_servidor_rechaza_se_muestra_su_mensaje_y_no_se_cierra() {
        val viewModel = nuevoViewModel()
        viewModel.escribirUnAvisoValido()
        api.errorAlCrear = errorDelServidor(413, "La imagen es demasiado grande")
        var publicado = false

        viewModel.publicar { publicado = true }

        assertEquals("La imagen es demasiado grande", viewModel.uiState.error)
        assertEquals(false, publicado)
        assertNull(viewModel.uiState.etapa)
    }

    @Test
    fun si_la_imagen_subio_pero_el_aviso_fallo_la_app_no_dice_que_se_publico() {
        val viewModel = nuevoViewModel()
        viewModel.escribirUnAvisoValido()
        viewModel.onImagenElegida(fotoDePrueba(contexto, 800, 600))
        api.errorAlCrear = errorDelServidor(422, "Esa imagen no existe")
        var publicado = false

        viewModel.publicar { publicado = true }
        viewModel.esperarQueTermine()

        assertEquals(listOf("subirImagen", "crearAviso"), api.llamadas)
        assertEquals(false, publicado)
        assertEquals("Esa imagen no existe", viewModel.uiState.error)
    }

    @Test
    fun lo_que_se_escribio_vuelve_si_android_recrea_el_viewmodel() {
        // El mismo SavedStateHandle en dos ViewModels: es lo que Android hace al recrear
        // la pantalla después de matar el proceso.
        val guardado = SavedStateHandle()
        val antes = nuevoViewModel(guardado)
        antes.escribirUnAvisoValido()

        val despues = nuevoViewModel(guardado)

        assertEquals("Examen parcial", despues.uiState.titulo)
        assertEquals("El jueves a las 10:00 en el salón de siempre.", despues.uiState.cuerpo)
    }
}

[versions]
espresso = "3.7.0"

[libraries]
androidx-compose-ui-test-junit4 = { group = "androidx.compose.ui", name = "ui-test-junit4" }
androidx-compose-ui-test-manifest = { group = "androidx.compose.ui", name = "ui-test-manifest" }
androidx-test-espresso-core = { group = "androidx.test.espresso", name = "espresso-core", version.ref = "espresso" }

    androidTestImplementation(platform(libs.androidx.compose.bom))
    androidTestImplementation(libs.androidx.compose.ui.test.junit4)
    // Compose UI Test trae Espresso 3.5.0, que truena en Android reciente: busca
    // InputManager.getInstance(), que ya no existe. La 3.7.0 pide el InputManager al sistema.
    androidTestImplementation(libs.androidx.test.espresso.core)
    // Compose necesita una Activity vacía donde dibujar la pantalla que se prueba.
    debugImplementation(libs.androidx.compose.ui.test.manifest)

package mx.tec.avisos.ui.screens

import android.net.Uri
import androidx.compose.ui.test.assertIsDisplayed
import androidx.compose.ui.test.assertIsEnabled
import androidx.compose.ui.test.assertIsNotEnabled
import androidx.compose.ui.test.junit4.createComposeRule
import androidx.compose.ui.test.onNodeWithContentDescription
import androidx.compose.ui.test.onNodeWithText
import androidx.compose.ui.test.performClick
import androidx.test.ext.junit.runners.AndroidJUnit4
import mx.tec.avisos.ui.state.PublicarUiState
import mx.tec.avisos.ui.theme.AvisosTheme
import org.junit.Assert.assertEquals
import org.junit.Rule
import org.junit.Test
import org.junit.runner.RunWith

/**
 * La pantalla de publicar, sola, sin ViewModel: es "tonta" (recibe un estado y
 * avisa con funciones), y por eso se puede dibujar con cualquier estado que la
 * prueba invente. Las pruebas buscan los elementos como lo haría TalkBack: por
 * su texto o por su descripción, no por su posición.
 */
@RunWith(AndroidJUnit4::class)
class PublicarScreenTest {

    @get:Rule
    val compose = createComposeRule()

    private var publicaciones = 0

    private fun mostrar(estado: PublicarUiState) {
        compose.setContent {
            AvisosTheme {
                PublicarScreen(
                    uiState = estado,
                    autor = "ana",
                    onTituloChange = {}, onCuerpoChange = {}, onGaleria = {}, onCamara = {}, onQuitarImagen = {},
                    onPublicar = { publicaciones++ }, onCancelar = {}
                )
            }
        }
    }

    @Test
    fun con_un_titulo_demasiado_corto_no_se_puede_publicar() {
        mostrar(PublicarUiState(titulo = "Ab", cuerpo = "El jueves a las 10:00."))

        compose.onNodeWithText("Publicar").assertIsNotEnabled()
    }

    @Test
    fun con_datos_validos_se_puede_publicar() {
        mostrar(PublicarUiState(titulo = "Examen parcial", cuerpo = "El jueves a las 10:00."))

        compose.onNodeWithText("Publicar").assertIsEnabled().performClick()

        assertEquals(1, publicaciones)
    }

    @Test
    fun mientras_sube_el_boton_dice_en_que_va_y_no_se_puede_tocar() {
        mostrar(PublicarUiState(titulo = "Examen parcial", cuerpo = "El jueves a las 10:00.", etapa = "Subiendo la imagen…"))

        compose.onNodeWithText("Subiendo la imagen…").assertIsDisplayed().assertIsNotEnabled()
    }

    @Test
    fun el_mensaje_del_servidor_se_ve() {
        mostrar(PublicarUiState(titulo = "Examen parcial", cuerpo = "El jueves a las 10:00.", error = "La imagen es demasiado grande"))

        compose.onNodeWithText("La imagen es demasiado grande").assertIsDisplayed()
    }

    @Test
    fun la_imagen_elegida_se_anuncia_y_se_puede_quitar() {
        mostrar(PublicarUiState(titulo = "Examen parcial", cuerpo = "El jueves a las 10:00.", imagen = Uri.parse("content://prueba/foto.jpg")))

        // Sin descripción, TalkBack diría solo "imagen": quien no ve no sabría qué es.
        compose.onNodeWithContentDescription("Imagen del aviso").assertExists()
        compose.onNodeWithText("Quitar").assertIsDisplayed()
    }
}

    fun tituloValido(titulo: String): Boolean = titulo.trim().length in TITULO_MIN until TITULO_MAX

        minutos <= 60 -> "hace $minutos min"

    fun publicar(alTerminar: () -> Unit) {
        viewModelScope.launch {

                contentDescription = null,

        const val LADO_MAX = 12800

package mx.tec.avisos.data.imagenes

import android.graphics.BitmapFactory
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.platform.app.InstrumentationRegistry
import kotlinx.coroutines.runBlocking
import mx.tec.avisos.fotoDePrueba
import org.junit.Assert.assertEquals
import org.junit.Test
import org.junit.runner.RunWith

/**
 * La prueba que faltaba: ningún mutante del compresor la ponía en rojo, porque
 * nadie comprobaba el tamaño de lo que sale. Se mide decodificando solo las
 * medidas del JPEG que devuelve, sin cargarlo.
 */
@RunWith(AndroidJUnit4::class)
class CompresorDeImagenTest {

    private val contexto = InstrumentationRegistry.getInstrumentation().targetContext
    private val compresor = CompresorDeImagen(contexto)

    private fun medidasDe(jpeg: ByteArray): Pair<Int, Int> {
        val opciones = BitmapFactory.Options().apply { inJustDecodeBounds = true }
        BitmapFactory.decodeByteArray(jpeg, 0, jpeg.size, opciones)
        return opciones.outWidth to opciones.outHeight
    }

    @Test
    fun una_foto_grande_sale_con_1280_px_en_su_lado_mas_largo() = runBlocking {
        val (ancho, alto) = medidasDe(compresor.comprimir(fotoDePrueba(contexto, 3000, 2000)))

        assertEquals(1280, ancho)
        assertEquals(853, alto)
    }

    @Test
    fun una_foto_chica_no_se_agranda() = runBlocking {
        val (ancho, alto) = medidasDe(compresor.comprimir(fotoDePrueba(contexto, 800, 600)))

        assertEquals(800, ancho)
        assertEquals(600, alto)
    }
}

git commit -m "checkpoint b4: el viewmodel contra un servidor de mentira" -m "Co-Authored-By: Claude <noreply@anthropic.com>"