Testes Unitários de Coroutines no Android com CoroutineTestRule

As Coroutines se estabeleceram como uma ferramenta essencial para gerenciar operações assíncronas no desenvolvimento Android. Contudo, a natureza assíncrona das coroutines pode apresentar desafios significativos para a escrita de testes unitários robustos e confiáveis. Este artigo oferece uma abordagem eficaz para testar coroutines em ambientes Android, utilizando o CoroutineTestRule para simplificar e otimizar o processo de teste.

A Importância dos Testes para Coroutines

Em aplicações Android, coroutines são empregadas em diversas tarefas que demandam tempo, como requisições de rede, manipulações de banco de dados e operações de I/O. Sem uma estratégia de teste adequada, a complexidade inerente a esse código assíncrono pode ocultar defeitos difíceis de diagnosticar. Testes unitários para coroutines são cruciais para verificar se:

As operações assíncronas se comportam conforme o esperado.
A thread principal da UI é devidamente protegida contra bloqueios.
Exceções são capturadas e tratadas corretamente.
Recursos são liberados de forma apropriada.

Desafios Comuns em Testes de Coroutines

Testar coroutines no Android enfrenta três obstáculos primários:

Questões de Sincronização Assíncrona

O mecanismo de suspensão e retomada das coroutines pode fazer com que as asserções do teste sejam executadas antes que as operações assíncronas tenham sido concluídas. Isso pode levar a falsos positivos, onde o teste "passa" mas o código contém um bug.
Complexidade na Gerência de Dispatchers

Coroutines em Android frequentemente utilizam dispatchers específicos, como Dispatchers.Main ou Dispatchers.IO. Tentar executar código que depende desses dispatchers em um ambiente de teste padrão pode resultar em erros relacionados a threads ou bloqueios.
Eficiência dos Testes

Permitir que todas as operações assíncronas se executem em tempo real pode prolongar consideravelmente a duração dos testes, impactando a produtividade do desenvolvimento.

`CoroutineTestRule`: A Solução Definitiva para Testes

O CoroutineTestRule é uma TestRule que aborda esses desafios de forma eficaz, proporcionando:

Um despachante de coroutines dedicado e controlável para testes.
Gerenciamento automático do ciclo de vida das coroutines durante os testes.
Capacidade de simular a execução síncrona de código assíncrono.
Um fluxo de trabalho simplificado para a escrita de testes.

Configuração Rápida

Adicionar Dependência

Inclua a seguinte dependência de teste no arquivo build.gradle do seu módulo:
```
testImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:1.7.3"
```

Criar a `RegraTesteCoroutines`

Defina sua própria regra de teste na pasta de testes do projeto:

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.test.TestDispatcher
import kotlinx.coroutines.test.UnconfinedTestDispatcher
import kotlinx.coroutines.test.resetMain
import kotlinx.coroutines.test.setMain
import org.junit.rules.TestWatcher
import org.junit.runner.Description

@ExperimentalCoroutinesApi
class RegraTesteCoroutines(
   val despachanteDeTeste: TestDispatcher = UnconfinedTestDispatcher()
) : TestWatcher() {
   /**
    * Define o Dispatcher principal para o despachante de teste antes de cada teste.
    */
   override fun starting(description: Description) {
       Dispatchers.setMain(despachanteDeTeste)
   }

   /**
    * Restaura o Dispatcher principal original após cada teste.
    */
   override fun finished(description: Description) {
       Dispatchers.resetMain()
   }
}

Aplicar em Seus Testes

Adicione a regra à sua classe de teste unitário:

import org.junit.Rule

// ...
class MeuComponenteTeste {
   @get:Rule
   val regraCoroutines = RegraTesteCoroutines()
   // ...
}

Exemplo Prático: Testando um ViewModel com Coroutines

Vamos demonstrar como usar RegraTesteCoroutines para testar um ViewModel que carrega dados de forma assíncrona.

Cenário de Teste

Verificar se um MeuViewModel executa corretamente uma operação de carregamento de dados e retorna o resultado esperado.

Implementação do Código de Teste

import com.google.common.truth.Truth.assertThat
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.test.runTest
import org.junit.Before
import org.junit.Rule
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.runners.JUnit4
import org.mockito.Mockito.mock
import org.mockito.Mockito.`when`
import java.io.IOException

// Supondo uma classe de modelo de dados simplificada
data class ItemDeDados(val id: String, val descricao: String)

// Interface de um repositório mockável
interface RepositorioDados {
   suspend fun obterTodosOsItens(): List<itemdedados>
}

// ViewModel de exemplo que utiliza coroutines
class MeuViewModel(private val repositorio: RepositorioDados) {
   suspend fun carregarItens(): List<itemdedados> {
       return repositorio.obterTodosOsItens()
   }
}

@ExperimentalCoroutinesApi
@RunWith(JUnit4::class)
class MeuViewModelTeste {
   @get:Rule
   val regraCoroutines = RegraTesteCoroutines() // Utilizando a regra customizada

   private lateinit var meuViewModel: MeuViewModel
   private lateinit var mockRepositorio: RepositorioDados

   @Before
   fun configurar() {
       mockRepositorio = mock(RepositorioDados::class.java)
       meuViewModel = MeuViewModel(mockRepositorio)
   }

   @Test
   fun `quando carregar itens, deve retornar a lista de dados esperada`() = runTest {
       // Cenário: Preparar dados de teste
       val itensMock = listOf(ItemDeDados(id = "a1", descricao = "Primeiro Item"), ItemDeDados(id = "b2", descricao = "Segundo Item"))
       `when`(mockRepositorio.obterTodosOsItens()).thenReturn(itensMock)

       // Ação: Executar a função que será testada
       val resultadoObtido = meuViewModel.carregarItens()

       // Verificação: Afirmar que o resultado corresponde aos dados mockados
       assertThat(resultadoObtido).isEqualTo(itensMock)
   }
}</itemdedados></itemdedados>

Técnicas Essenciais de Teste

1. Controlando o Tempo com `TestDispatcher`

Para testar operações com atrasos (delay()), utilize StandardTestDispatcher e a função advanceUntilIdle() para simular o avanço do tempo instantaneamente:

import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.test.StandardTestDispatcher
import kotlinx.coroutines.test.advanceUntilIdle
import kotlinx.coroutines.test.runTest
import org.junit.Test
import com.google.common.truth.Truth.assertThat

class TesteOperacaoComAtraso {
   @Test
   fun `testar operacao com atraso deve ser concluida apos advanceUntilIdle`() = runTest {
       val despachanteSimulado = StandardTestDispatcher(testScheduler)
       var valorModificado = 0

       launch(despachanteSimulado) {
           delay(1000) // Simula um atraso de 1 segundo
           valorModificado = 1
       }

       assertThat(valorModificado).isEqualTo(0) // Ainda não foi modificado
       advanceUntilIdle() // Executa todas as coroutines pendentes até que estejam ociosas
       assertThat(valorModificado).isEqualTo(1) // Agora o valor foi atualizado
   }
}

2. Testando o Tratamento de Exceções

Para verificar se as exceções são tratadas corretamente, você pode usar assertFailsWith:

import kotlinx.coroutines.test.runTest
import org.junit.Test
import kotlin.test.assertFailsWith
import java.io.IOException
import org.mockito.Mockito.`when`

class TesteTratamentoExcecao {
   @get:Rule
   val regraCoroutines = RegraTesteCoroutines()

   private lateinit var meuViewModel: MeuViewModel
   private lateinit var mockRepositorio: RepositorioDados

   @Before
   fun setup() {
       mockRepositorio = mock(RepositorioDados::class.java)
       meuViewModel = MeuViewModel(mockRepositorio)
   }

   @Test
   fun `testar que excecao de IO e lancada ao carregar itens`() = runTest {
       `when`(mockRepositorio.obterTodosOsItens()).thenThrow(IOException("Erro de rede simulado"))

       assertFailsWith<ioexception> {
           meuViewModel.carregarItens()
       }
   }
}</ioexception>

Estratégias Avançadas de Teste

1. Testando Coroutines em ViewModels

Ao testar ViewModels que iniciam coroutines, como aqueles que buscam dados ou atualizam estados reativamente, é crucial garantir que as operações assíncronas modifiquem o estado do ViewModel de maneira previsível.

import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.test.runTest
import org.junit.Rule
import org.junit.Test
import com.google.common.truth.Truth.assertThat

data class EstadoUI(val carregando: Boolean, val mensagem: String?)

class MeuViewModelComEstado(private val tempoSimuladoMs: Long = 0L) : ViewModel() {
   private val _estado = MutableLiveData(EstadoUI(carregando = false, null))
   val estado: LiveData<estadoui> = _estado

   fun buscarDados() {
       viewModelScope.launch {
           _estado.value = EstadoUI(carregando = true, null)
           delay(tempoSimuladoMs) // Simula uma operação demorada
           _estado.value = EstadoUI(carregando = false, "Dados Carregados!")
       }
   }
}

@ExperimentalCoroutinesApi
class MeuViewModelComEstadoTeste {
   @get:Rule
   val regraCoroutines = RegraTesteCoroutines() // Usando UnconfinedTestDispatcher por padrão

   @Test
   fun `quando buscar dados, estado deve indicar carregamento e depois sucesso`() = runTest {
       val viewModel = MeuViewModelComEstado(tempoSimuladoMs = 100) // Simula 100ms de atraso

       // Observa o estado como se estivesse em um ciclo de vida de UI
       val observador = TestObserver<estadoui>()
       viewModel.estado.observeForever(observador)

       // Estado inicial
       assertThat(observador.values.first().carregando).isFalse()

       // Iniciar busca
       viewModel.buscarDados()

       // Com UnconfinedTestDispatcher, o delay é ignorado, mas a mudança de estado ocorre em sequence.
       // A próxima linha de código no job será executada imediatamente após o delay.
       // Se usar StandardTestDispatcher, seria necessário advanceUntilIdle()

       // Verifica estado de carregamento
       assertThat(observador.values[1].carregando).isTrue()

       // Verifica estado final
       assertThat(observador.values[2].carregando).isFalse()
       assertThat(observador.values[2].mensagem).isEqualTo("Dados Carregados!")

       observador.dispose() // Limpa o observador
   }

   // Helper para observar LiveData em testes
   class TestObserver<t> : androidx.lifecycle.Observer<t> {
       val values = mutableListOf<t>()
       override fun onChanged(t: T) {
           values.add(t)
       }
       fun dispose() {
           // Em cenários reais, remove o observador da LiveData
           // Para este mock, apenas limpamos os valores
           values.clear()
       }
   }
}</t></t></t></estadoui></estadoui>

2. Testando Funções Suspend

Para funções suspend utilitárias ou de camada de dados, o teste pode ser mais direto, encapsulando a chamada dentro de runTest.

import kotlinx.coroutines.delay
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.test.runTest
import org.junit.Test
import com.google.common.truth.Truth.assertThat

object UtilitarioAsync {
   suspend fun executarOperacaoDemorada(entrada: String): String {
       delay(50) // Simula algum trabalho
       return "Processado: $entrada"
   }
}

@ExperimentalCoroutinesApi
class UtilitarioAsyncTeste {
   @Test
   fun `testar execucao de operacao demorada deve retornar resultado correto`() = runTest {
       val resultado = UtilitarioAsync.executarOperacaoDemorada("dados iniciais")
       assertThat(resultado).isEqualTo("Processado: dados iniciais")
   }
}

3. Testando Interações entre Múltiplas Coroutines

Para cenários onde várias coroutines interagem ou são executadas concorrentemente, runTest e os despachantes de teste permitem coordenar suas execuções.

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.delay
import kotlinx.coroutines.joinAll
import kotlinx.coroutines.launch
import kotlinx.coroutines.test.runTest
import org.junit.Rule
import org.junit.Test
import com.google.common.truth.Truth.assertThat

@ExperimentalCoroutinesApi
class TesteOperacoesConcorrentes {
   @get:Rule
   val regraCoroutines = RegraTesteCoroutines()

   @Test
   fun `testar que multiplas coroutines completam a execucao`() = runTest {
       val escopoTeste = CoroutineScope(regraCoroutines.despachanteDeTeste)
       var contador = 0

       val job1 = escopoTeste.launch {
           delay(100)
           contador += 1
       }
       val job2 = escopoTeste.launch {
           delay(200)
           contador += 1
       }

       // Aguarda a conclusão de ambas as coroutines no ambiente de teste
       joinAll(job1, job2)

       // Ambos os atrasos são efetivamente ignorados ou avançados,
       // garantindo que as operações sejam concluídas.
       assertThat(contador).isEqualTo(2)
   }
}

Problemas Comuns e Suas Soluções

Problema 1: Erro "Main dispatcher has not been set" no teste

Solução: Certifique-se de que o CoroutineTestRule (ou sua versão customizada RegraTesteCoroutines) esteja aplicado corretamente com @get:Rule em sua classe de teste, e que ele configure e reinicie o Dispatcher principal conforme demonstrado.

@get:Rule
val regraCoroutines = RegraTesteCoroutines()

Problema 2: Testes falham intermitentemente ou de forma inconsistente

Solução: Isso geralmente indica que as asserções estão sendo executadas antes que todas as coroutines assíncronas tenham sido concluídas. Utilize advanceUntilIdle() dentro do seu bloco runTest para garantir que todas as coroutines pendentes no despachante de teste terminem suas execuções antes de fazer as verificações.

@Test
fun `testar operacao assincrona completa com advanceUntilIdle`() = runTest {
   launch {
       // ... execute uma operação assíncrona
       delay(50)
       // ...
   }
   advanceUntilIdle() // Espera que todas as coroutines pendentes terminem
   // Faça suas asserções aqui
}

Problema 3: Testes de coroutines demoram muito para executar

Solução: Verifique se você está utilizando TestDispatcher (como UnconfinedTestDispatcher ou StandardTestDispatcher) em vez dos dispatchers reais (Dispatchers.IO, Dispatchers.Default). O UnconfinedTestDispatcher é particularmente útil para acelerar testes, pois executa coroutines imediatamente na thread atual, ignorando atrasos. Sua RegraTesteCoroutines padrão já utiliza UnconfinedTestDispatcher.

@get:Rule
val regraCoroutines = RegraTesteCoroutines(UnconfinedTestDispatcher()) // Explícito, mas é o padrão

Conclusão

A incorporação de CoroutineTestRule e as estratégias de teste discutidas neste artigo fornecem uma base sólida para testar coroutines em Android. Ao adotar essas práticas, você pode:

Garentir a Qualidade do Código Assíncrono: Testes abrangentes para a lógica de coroutines reduzem a ocorrência de bugs em produção.
Aumentar a Eficiência dos Testes: Utilizar despachantes de teste acelera a execução dos testes, otimizando o ciclo de desenvolvimento.
Simplificar a Escrita de Testes: Um padrão consistente para testar coroutines diminui a curva de aprendizado e a carga cognitiva.

Dominar os testes de coroutines não apenas eleva a qualidade do seu código, mas também aumenta sua confiança ao empregar coroutines para resolver lógicas assíncronas complexas no desenvolvimento Android.

Tags: android Kotlin Coroutines Unit Testing CoroutineTestRule Dispatchers

Publicado em 6-9 01:09 por Thomas

Doido Dev

Testes Unitários de Coroutines no Android com CoroutineTestRule

A Importância dos Testes para Coroutines

Desafios Comuns em Testes de Coroutines

Questões de Sincronização Assíncrona

Complexidade na Gerência de Dispatchers

Eficiência dos Testes

`CoroutineTestRule`: A Solução Definitiva para Testes

Configuração Rápida

Adicionar Dependência

Criar a `RegraTesteCoroutines`

Aplicar em Seus Testes

Exemplo Prático: Testando um ViewModel com Coroutines

Cenário de Teste

Implementação do Código de Teste

Técnicas Essenciais de Teste

1. Controlando o Tempo com `TestDispatcher`

2. Testando o Tratamento de Exceções

Estratégias Avançadas de Teste

1. Testando Coroutines em ViewModels

2. Testando Funções Suspend

3. Testando Interações entre Múltiplas Coroutines

Problemas Comuns e Suas Soluções

Problema 1: Erro "Main dispatcher has not been set" no teste

Problema 2: Testes falham intermitentemente ou de forma inconsistente

Problema 3: Testes de coroutines demoram muito para executar

Conclusão

Tags em Destaque

Doido Dev

Testes Unitários de Coroutines no Android com CoroutineTestRule

A Importância dos Testes para Coroutines

Desafios Comuns em Testes de Coroutines

Questões de Sincronização Assíncrona

Complexidade na Gerência de Dispatchers

Eficiência dos Testes

CoroutineTestRule: A Solução Definitiva para Testes

Configuração Rápida

Adicionar Dependência

Criar a RegraTesteCoroutines

Aplicar em Seus Testes

Exemplo Prático: Testando um ViewModel com Coroutines

Cenário de Teste

Implementação do Código de Teste

Técnicas Essenciais de Teste

1. Controlando o Tempo com TestDispatcher

2. Testando o Tratamento de Exceções

Estratégias Avançadas de Teste

1. Testando Coroutines em ViewModels

2. Testando Funções Suspend

3. Testando Interações entre Múltiplas Coroutines

Problemas Comuns e Suas Soluções

Problema 1: Erro "Main dispatcher has not been set" no teste

Problema 2: Testes falham intermitentemente ou de forma inconsistente

Problema 3: Testes de coroutines demoram muito para executar

Conclusão

Tags em Destaque

`CoroutineTestRule`: A Solução Definitiva para Testes

Criar a `RegraTesteCoroutines`

1. Controlando o Tempo com `TestDispatcher`