Kotlin Academy · Lezione

Test delle coroutine

Testi le funzioni suspend

Test delle coroutine è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.

Perché i test delle coroutine sono speciali

Le coroutine vengono eseguite in modo asincrono e possono usare dei ritardi. I test hanno bisogno del tempo controllato e di un modo per attendere il completamento delle funzioni suspend.

La libreria kotlinx-coroutines-test fornisce esattamente queste funzionalità.

Aggiunta della libreria di test

Aggiunga l'artifact di test per le coroutine alle dipendenze di test.

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

runTest

runTest è il punto di ingresso. Esegue il corpo di un test per coroutine e attende automaticamente il completamento di tutte le coroutine figlie.

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

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

Tempo virtuale

All'interno di runTest, le chiamate a delay vengono saltate usando il tempo virtuale. Un ritardo di 10 secondi termina istantaneamente, mantenendo però l'ordine delle operazioni.

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

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

Avanzamento manuale del tempo

Lo scheduler di test consente di far avanzare deliberatamente il tempo con advanceTimeBy e di eseguire il lavoro in attesa 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()
// }

Dispatcher di test

StandardTestDispatcher accoda le coroutine finché non fa avanzare il tempo. UnconfinedTestDispatcher le esegue immediatamente. Scelga in base al livello di controllo necessario.

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

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

Iniezione di un dispatcher

Il codice di produzione dovrebbe accettare un dispatcher invece di codificare direttamente Dispatchers.IO. I test possono quindi iniettare un dispatcher di 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" }
}

Sostituzione di Dispatchers.Main

Per il codice in stile Android, sostituisca il dispatcher Main con Dispatchers.setMain(testDispatcher) e lo reimposti al termine.

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

Test di una funzione suspend

Una funzione suspend può essere chiamata e verificata direttamente all'interno di 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())
// }

Test dei Flow

Raccolga i valori emessi da un Flow e li verifichi. La libreria Turbine rende particolarmente puliti i test dei flow.

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 frammento di coroutine eseguibile

Al di fuori dei test, runBlocking collega il codice suspend a un main normale. Questo illustra la funzione suspend sottoposta al test.

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

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

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

Verifica rapida

Una funzione suspend chiama delay(5000). Perché un test che usa runTest termina quasi istantaneamente?

Riepilogo

Ora può testare le coroutine in modo affidabile:

runTest esegue il codice suspend e attende le coroutine figlie
Il tempo virtuale salta i ritardi; lo faccia avanzare manualmente quando necessario
Inietti i dispatcher; usi setMain/resetMain
Testi i flow raccogliendone i valori (oppure con Turbine)

Il corso Testing è terminato.

Domande Frequenti

La lezione «Test delle coroutine» è gratuita?

Sì — il testo completo di «Test delle coroutine» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Kotlin Academy, passa a CoddyKit PRO. Il corso Kotlin Academy include 4 lezioni in totale.

Cosa imparerò in «Test delle coroutine»?

Testi le funzioni suspend Eserciti Kotlin Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Kotlin Academy?

Non è richiesta alcuna esperienza precedente. Kotlin Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Test delle coroutine»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Kotlin Academy?

Sì. Ogni lezione Kotlin Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Kotlin Academy