Turbine para Kotlin: guia completo para testar Flow

1. O que é e para que serve

A biblioteca Turbine é uma ferramenta moderna para testar fluxos de dados assíncronos (Flow) na linguagem Kotlin. Desenvolvida pela Cash App, a Turbine resolve um dos problemas mais difíceis ao escrever testes unitários para código assíncrono: a complexidade de verificar a emissão de valores de um Flow, tratamento de erros e conclusão do fluxo. Diferente das abordagens padrão, como usar kotlinx-coroutines-test com coleta manual de elementos, a Turbine oferece uma API declarativa e intuitiva que torna os testes legíveis e confiáveis.

Para que serve a Turbine? Imagine que você está escrevendo uma ViewModel que se inscreve em um repositório e transforma os dados em estado de UI. Sem a Turbine, você precisaria criar coletores manualmente, gerenciar Jobs e sincronizar corrotinas. A Turbine automatiza esse processo: ela cria uma corrotina virtual, coleta todas as emissões em uma "turbina" (daí o nome) e permite verificar cada valor em ordem, ignorando estados intermediários irrelevantes. Isso é especialmente útil ao testar fluxos semelhantes a BehaviorSubject, onde apenas o estado final importa.

Os principais recursos da biblioteca incluem: verificação de valores emitidos em ordem estrita, ignorar valores intermediários com skip(), testar erros com awaitError(), verificar a conclusão do fluxo com awaitComplete(), além de suporte a canais (Channel) e StateFlow. A Turbine se integra com qualquer framework de teste (JUnit, Kotest, Spek) e não requer configurações adicionais — basta adicionar a dependência e usar testScope.

2. Instalação

Para usar a Turbine no seu projeto, adicione a seguinte dependência no arquivo build.gradle.kts (ou build.gradle):

// build.gradle.kts
dependencies {
    // Para projetos JVM
    testImplementation("app.cash.turbine:turbine:1.1.0")
    
    // Se estiver usando kotlinx-coroutines-test (recomendado)
    testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.9.0")
}

// Para projetos Android (no bloco android)
android {
    testOptions {
        unitTests.isReturnDefaultValues = true
    }
}

Se você usa Maven:

<dependency>
    <groupId>app.cash.turbine</groupId>
    <artifactId>turbine</artifactId>
    <version>1.1.0</version>
    <scope>test</scope>
</dependency>

Requisitos mínimos: Kotlin 1.9+, kotlinx-coroutines 1.8+. A biblioteca suporta JVM, Android, JS e Native (via Kotlin Multiplatform).

3. Início rápido

Vamos ver um exemplo simples: testar um Flow que emite três números.

import app.cash.turbine.test
import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.test.runTest
import org.junit.Test

class SimpleTurbineTest {

    @Test
    fun `test flow emite tres valores`() = runTest {
        val flow = flowOf(1, 2, 3)

        flow.test {
            // awaitItem() aguarda a próxima emissão e a retorna
            assertEquals(1, awaitItem())
            assertEquals(2, awaitItem())
            assertEquals(3, awaitItem())

            // awaitComplete() verifica se o fluxo foi concluído sem erros
            awaitComplete()
        }
    }
}

Execute este teste — ele passará com sucesso. Observe: test é uma função suspend que inicia a coleta do fluxo em uma corrotina separada. Todas as chamadas awaitItem() bloqueiam a corrotina atual até que o próximo elemento apareça. Se o fluxo terminar antes do esperado, o teste falhará com uma mensagem de erro clara.

4. Métodos/funções principais