Kotlin Academy · Leçon

Tests des coroutines

Tester les fonctions suspendues

Tests des coroutines est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.

Pourquoi les tests de coroutines sont particuliers

Les coroutines s’exécutent de manière asynchrone et peuvent utiliser des délais. Les tests ont besoin d’un temps contrôlé et d’un moyen d’attendre la fin des fonctions suspendues.

La bibliothèque kotlinx-coroutines-test fournit précisément ces fonctionnalités.

Ajouter la bibliothèque de test

Ajoutez l’artefact de test des coroutines à vos dépendances de test.

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

runTest

runTest est le point d’entrée. Il exécute le corps d’un test de coroutine et attend automatiquement que toutes les coroutines enfants se terminent.

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

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

Temps virtuel

Dans runTest, les appels à delay sont ignorés grâce au temps virtuel. Un délai de 10 secondes s’achève instantanément tout en conservant l’ordre d’exécution.

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

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

Avancer manuellement le temps

Le planificateur de test vous permet d’avancer volontairement le temps avec advanceTimeBy et d’exécuter le travail en attente avec 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 test

StandardTestDispatcher met les coroutines en file d’attente jusqu’à ce que vous avanciez le temps. UnconfinedTestDispatcher les exécute immédiatement. Choisissez selon le niveau de contrôle dont vous avez besoin.

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

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

Injecter un dispatcher

Le code de production doit accepter un dispatcher plutôt que de coder en dur Dispatchers.IO. Les tests peuvent alors injecter un dispatcher de test.

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" }
}

Remplacer Dispatchers.Main

Pour le code de style Android, remplacez le dispatcher Main par Dispatchers.setMain(testDispatcher), puis réinitialisez-le.

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()

Tester une fonction suspendue

Une fonction suspendue peut être appelée et vérifiée directement dans 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())
// }

Tester les flux

Collectez un Flow et vérifiez les valeurs émises. La bibliothèque Turbine rend particulièrement simple le test des flux.

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 extrait de coroutine exécutable

En dehors des tests, runBlocking relie le code suspendu à un main normal. Cela illustre la fonction suspendue testée.

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

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

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

Vérification rapide

Une fonction suspendue appelle delay(5000). Pourquoi un test utilisant runTest s’achève-t-il presque instantanément ?

Récapitulatif

Vous pouvez tester les coroutines de manière fiable :

runTest exécute le code suspendu et attend les coroutines enfants
Le temps virtuel ignore les délais ; avancez-le manuellement si nécessaire
Injectez les dispatchers ; utilisez setMain/resetMain
Testez les flux en les collectant (ou avec Turbine)

Le cours sur les tests est maintenant terminé.

Questions Fréquemment Posées

La leçon « Tests des coroutines » est-elle gratuite ?

Oui — le texte complet de « Tests des coroutines » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Kotlin Academy, passe à CoddyKit PRO. Le cours Kotlin Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Tests des coroutines » ?

Tester les fonctions suspendues Tu pratiques Kotlin Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Kotlin Academy ?

Aucune expérience préalable n'est requise. Kotlin Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Tests des coroutines » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Kotlin Academy ?

Oui. Chaque leçon Kotlin Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Kotlin Academy