Kotlin Academy · Lektion

Coroutine-Tests

Testen Sie suspend-Funktionen

Coroutine-Tests ist eine kostenlose Kotlin Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Kotlin Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Warum das Testen von Coroutines besonders ist

Coroutines werden asynchron ausgeführt und können Verzögerungen enthalten. Tests benötigen eine kontrollierte Zeit und eine Möglichkeit, auf den Abschluss von Suspend-Funktionen zu warten.

Die Bibliothek kotlinx-coroutines-test stellt genau das bereit.

Die Testbibliothek hinzufügen

Fügen Sie das Coroutines-Test-Artefakt zu Ihren Testabhängigkeiten hinzu.

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

runTest

runTest ist der Einstiegspunkt. Es führt den Body eines Coroutine-Tests aus und wartet automatisch, bis alle untergeordneten Coroutines abgeschlossen sind.

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

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

Virtuelle Zeit

Innerhalb von runTest werden Aufrufe von delay mithilfe virtueller Zeit übersprungen. Eine Verzögerung von 10 Sekunden ist sofort abgeschlossen, wobei die Reihenfolge erhalten bleibt.

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

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

Zeit manuell voranbringen

Mit dem Test-Scheduler können Sie die Zeit mit advanceTimeBy gezielt voranbringen und ausstehende Arbeit mit runCurrent ausführen.

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

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

Test-Dispatcher

StandardTestDispatcher reiht Coroutines ein, bis Sie die Zeit voranbringen. UnconfinedTestDispatcher führt sie sofort aus. Wählen Sie abhängig davon, wie viel Kontrolle Sie benötigen.

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

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

Einen Dispatcher injizieren

Produktionscode sollte einen Dispatcher akzeptieren, statt Dispatchers.IO fest zu codieren. Tests können dann einen Test-Dispatcher injizieren.

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

Dispatchers.Main ersetzen

Für Code im Android-Stil ersetzen Sie den Main-Dispatcher durch Dispatchers.setMain(testDispatcher) und setzen ihn anschließend zurück.

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

Eine Suspend-Funktion testen

Eine Suspend-Funktion kann innerhalb von runTest direkt aufgerufen und überprüft werden.

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

Flows testen

Sammeln Sie einen Flow und überprüfen Sie die emittierten Werte. Die Bibliothek Turbine macht das Testen von Flows besonders übersichtlich.

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)
// }

Ein ausführbarer Coroutine-Ausschnitt

Außerhalb von Tests verbindet runBlocking Suspend-Code mit einem normalen main. Dies veranschaulicht die getestete Suspend-Funktion.

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

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

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

Kurze Überprüfung

Eine Suspend-Funktion ruft delay(5000) auf. Warum wird ein Test mit runTest nahezu sofort beendet?

Zusammenfassung

Sie können Coroutines zuverlässig testen:

runTest führt Suspend-Code aus und wartet auf untergeordnete Coroutines
Virtuelle Zeit überspringt Verzögerungen; bei Bedarf können Sie die Zeit manuell voranbringen
Dispatcher injizieren; setMain/resetMain verwenden
Flows durch Sammeln testen (oder mit Turbine)

Damit ist der Testing-Kurs abgeschlossen.

Häufig gestellte Fragen

Ist die Lektion „Coroutine-Tests“ kostenlos?

Ja — der vollständige Text von „Coroutine-Tests“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Kotlin Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Coroutine-Tests“?

Testen Sie suspend-Funktionen Du übst Kotlin Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Kotlin Academy zu starten?

Keine Vorkenntnisse erforderlich. Kotlin Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Coroutine-Tests“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Kotlin Academy-Lektion Code schreiben und ausführen?

Ja. Jede Kotlin Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Kotlin Academy