Kotlin Academy · Aula

Testes de Corrotinas

Teste funções suspensas

Testes de Corrotinas é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Kotlin Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kotlin Academy inclui 4 aulas no total.

Por que testar corrotinas é diferente

As corrotinas são executadas de forma assíncrona e podem usar atrasos. Os testes precisam de tempo controlado e de uma forma de aguardar a conclusão das funções suspensas.

A biblioteca kotlinx-coroutines-test fornece exatamente isso.

Adicionando a biblioteca de testes

Adicione o artefato de testes de corrotinas às dependências de teste.

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

runTest

runTest é o ponto de entrada. Ele executa o corpo de um teste de corrotina e aguarda automaticamente a conclusão de todas as corrotinas filhas.

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

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

Tempo virtual

Dentro de runTest, as chamadas a delay são ignoradas usando tempo virtual. Um atraso de 10 segundos é concluído instantaneamente, preservando a ordem.

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

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

Avançando o tempo manualmente

O agendador de testes permite avançar o tempo deliberadamente com advanceTimeBy e executar o trabalho pendente com 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()
// }

Despachantes de teste

StandardTestDispatcher coloca as corrotinas em uma fila até que você avance o tempo. UnconfinedTestDispatcher as executa imediatamente. Escolha com base no nível de controle de que você precisa.

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

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

Injetando um despachante

O código de produção deve receber um despachante, em vez de codificar Dispatchers.IO diretamente. Assim, os testes podem injetar um despachante de teste.

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

Substituindo Dispatchers.Main

Para código no estilo Android, substitua o despachante Main por Dispatchers.setMain(testDispatcher) e redefina-o depois.

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

Testando uma função suspensa

Uma função suspensa pode ser chamada e verificada diretamente 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())
// }

Testando fluxos

Colete um Flow e verifique os valores emitidos. A biblioteca Turbine torna os testes de fluxos especialmente simples.

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

Um trecho executável de corrotina

Fora dos testes, runBlocking conecta o código suspenso a um main normal. Isso ilustra a função suspensa que está sendo testada.

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

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

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

Verificação rápida

Uma função suspensa chama delay(5000). Por que um teste que usa runTest termina quase instantaneamente?

Recapitulação

Você pode testar corrotinas de forma confiável:

runTest executa código suspenso e aguarda as corrotinas filhas
O tempo virtual ignora os atrasos; avance-o manualmente quando necessário
Injete despachantes; use setMain/resetMain
Teste fluxos coletando seus valores (ou usando o Turbine)

Com isso, o curso de testes está concluído.

Perguntas Frequentes

A aula “Testes de Corrotinas” é grátis?

Sim — o texto completo de “Testes de Corrotinas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Kotlin Academy, atualize para CoddyKit PRO. O curso de Kotlin Academy inclui 4 aulas no total.

O que vou aprender em “Testes de Corrotinas”?

Teste funções suspensas Você pratica Kotlin Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Kotlin Academy?

Nenhuma experiência prévia é necessária. Kotlin Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Testes de Corrotinas”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Kotlin Academy?

Sim. Cada aula de Kotlin Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Kotlin Academy