Kotlin Academy · Lección

Pruebas de coroutines

Pruebe funciones suspend

Pruebas de coroutines es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Kotlin Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Kotlin Academy incluye 4 lecciones en total.

Por qué las pruebas de corrutinas son especiales

Las corrutinas se ejecutan de forma asíncrona y pueden utilizar retrasos. Las pruebas necesitan tiempo controlado y una forma de esperar a que terminen las funciones suspend.

La biblioteca kotlinx-coroutines-test proporciona exactamente eso.

Añadir la biblioteca de pruebas

Añada el artefacto de pruebas de corrutinas a sus dependencias de pruebas.

dependencies {
    testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.8.1")
}

runTest

runTest es el punto de entrada. Ejecuta el cuerpo de una prueba de corrutinas y espera automáticamente a que se completen todas las corrutinas hijas.

import kotlinx.coroutines.test.runTest
import org.junit.jupiter.api.Test

class FetchTest {
    @Test
    fun fetches() = runTest {
        // suspend calls allowed here
    }
}

Tiempo virtual

Dentro de runTest, las llamadas a delay se omiten mediante tiempo virtual. Un retraso de 10 segundos se completa al instante, conservando el orden.

import kotlinx.coroutines.delay
import kotlinx.coroutines.test.runTest

// runTest {
//     delay(10_000) // returns immediately
// }

Avanzar el tiempo manualmente

El planificador de pruebas permite avanzar el tiempo deliberadamente con advanceTimeBy y ejecutar el trabajo pendiente con runCurrent.

import kotlinx.coroutines.test.runTest
import kotlinx.coroutines.test.advanceTimeBy
import kotlinx.coroutines.test.runCurrent

// runTest {
//     launch { delay(1000); println("done") }
//     advanceTimeBy(1000)
//     runCurrent()
// }

Dispatchers de prueba

StandardTestDispatcher pone las corrutinas en cola hasta que avance el tiempo. UnconfinedTestDispatcher las ejecuta de forma inmediata. Elija uno según el nivel de control que necesite.

import kotlinx.coroutines.test.StandardTestDispatcher
import kotlinx.coroutines.test.UnconfinedTestDispatcher

val standard = StandardTestDispatcher()
val unconfined = UnconfinedTestDispatcher()

Inyectar un Dispatcher

El código de producción debe aceptar un dispatcher en lugar de codificar Dispatchers.IO directamente. De este modo, las pruebas pueden inyectar un dispatcher de prueba.

import kotlinx.coroutines.CoroutineDispatcher
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext

class Service(private val io: CoroutineDispatcher = Dispatchers.IO) {
    suspend fun load(): String = withContext(io) { "data" }
}

Sustituir Dispatchers.Main

Para código de estilo Android, sustituya el dispatcher Main por Dispatchers.setMain(testDispatcher) y restablézcalo después.

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.test.setMain
import kotlinx.coroutines.test.resetMain
import kotlinx.coroutines.test.StandardTestDispatcher

// Dispatchers.setMain(StandardTestDispatcher())
// ... test ...
// Dispatchers.resetMain()

Probar una función suspend

Puede llamar a una función suspend y comprobarla directamente dentro de runTest.

import kotlinx.coroutines.delay
import kotlinx.coroutines.test.runTest
import org.junit.jupiter.api.Assertions.assertEquals

suspend fun compute(): Int { delay(1000); return 42 }

// @Test fun computes() = runTest {
//     assertEquals(42, compute())
// }

Probar Flows

Recopile un Flow y compruebe los valores emitidos. La biblioteca Turbine facilita especialmente las pruebas de flows.

import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.flow.toList
import kotlinx.coroutines.test.runTest
import org.junit.jupiter.api.Assertions.assertEquals

// @Test fun emits() = runTest {
//     val values = flowOf(1, 2, 3).toList()
//     assertEquals(listOf(1, 2, 3), values)
// }

Un fragmento ejecutable de corrutinas

Fuera de las pruebas, runBlocking conecta el código suspend con un main normal. Esto ilustra la función suspend que se está probando.

import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.delay

suspend fun compute(): Int { delay(100); return 42 }

fun main() = runBlocking {
    println(compute())
}

Comprobación rápida

Una función suspend llama a delay(5000). ¿Por qué una prueba que utiliza runTest termina casi al instante?

Resumen

Puede probar corrutinas de forma fiable:

runTest ejecuta código suspend y espera a las corrutinas hijas
El tiempo virtual omite los retrasos; avance el tiempo manualmente cuando sea necesario
Inyecte dispatchers; use setMain/resetMain
Pruebe flows recopilándolos (o con Turbine)

Con esto termina el curso de testing.

Preguntas frecuentes

¿La lección «Pruebas de coroutines» es gratis?

Sí — el texto completo de «Pruebas de coroutines» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Kotlin Academy, actualiza a CoddyKit PRO. El curso de Kotlin Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Pruebas de coroutines»?

Pruebe funciones suspend Practicas Kotlin Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Kotlin Academy?

No se requiere experiencia previa. Kotlin Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Pruebas de coroutines»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Kotlin Academy?

Sí. Cada lección de Kotlin Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Kotlin Academy