Recentemente me tornei um fã do Android Kotlin e me converti. Então li sobre corrotinas e pensei que todo o meu Natal geek havia chegado de uma vez.

Corrotinas

As corrotinas em Kotlin permitem tarefas assíncronas fáceis. Com algumas linhas podemos fazer chamadas assíncronas e obter sua resposta

-- PRESENTER
fun getListOfThings() {
    launch(Android) {
        asyncTask { storageHelper.getListFromDb() }.await()
        .let { list -> 
            view.useTheResult(list)
        }
    }
}

fun <T> asyncTask(function: () -> T): Deferred<T> {
    return async(CommonPool) { function() }
}

• A classe Android é o código de Miguel Castiblanco diretamente deste excelente post
• asyncTask é uma função auxiliar que escrevi para reduzir o código e tornar as coisas um pouco mais organizadas.

Teste de unidade

Agora queremos testar a unidade do método getListOfThings . Primeiro, temos o problema de simulação em torno de classes e métodos Kotlin serem finais por padrão. Nada mal (abra-os ou use os recursos mais recentes do Mockito para simular o final).

Na minha implementação assíncrona anterior (RxJava), você pode facilmente trocar agendadores para teste, tornando assíncrono em síncrono para fins de teste. Isso se mostrou impossível usando corrotinas.

Em vez disso, tive que adotar uma abordagem diferente… primeiro vamos escrever um teste de unidade para getListOfThings :

-- TEST
@Test
fun getPackageFiltersForWidget() {
    val list: ArrayList<PackageFilter> = ArrayList()
    `when`(storageHelper.getListFromDb()).thenReturn(list)
    presenter.getListOfThings()
    Mockito.verify(view).useTheResult(ArgumentMatchers.eq(list))
}
-- PRESENTER
fun getListOfThings() {
    launch(Android) {
        asyncTask { storageHelper.getListFromDb() }.await()
        .let { list -> 
            view.useTheResult(list)
        }
    }
}

fun <T> asyncTask(function: () -> T): Deferred<T> {
    return async(CommonPool) { function() }
}
-- ACTIVITY
fun getList() {
    presenter.getListOfThings()
}

O que precisamos fazer é mover a seção de inicialização (Android) para fora do apresentador, para que possamos testar apenas a lógica. Mas não queremos que o método apresentador seja chamado no UI Thread.

Insira a palavra-chave suspend e runBlocking :

-- TEST
@Test
fun getPackageFiltersForWidget() {
    val list: ArrayList<PackageFilter> = ArrayList()
    `when`(storageHelper.getListFromDb()).thenReturn(list)
    runBlocking {    
        presenter.getListOfThings()
    }
    Mockito.verify(view).useTheResult(ArgumentMatchers.eq(list))
}
-- PRESENTER
suspend fun getListOfThings() {
    asyncTask { storageHelper.getListFromDb() }.await()
        .let { list -> 
            view.useTheResult(list)
    }
}

fun <T> asyncTask(function: () -> T): Deferred<T> {
    return async(CommonPool) { function() }
}
-- ACTIVITY
fun getList() {
    launch(Android) {    
        presenter.getListOfThings()
    }
}

Você obtém o mesmo erro dentro do teste, então envolva a chamada para o método getListOfThings com runBlocking .

Se fizermos o teste agora, tudo verde .. sim!

Configuração Kotlin

As corrotinas estão disponíveis apenas no Kotlin 1.1, que (no momento da escrita) está em RC.

Você precisará configurar seu projeto para usar 1.1 e, em seguida, adicionar a seguinte importação

compile "org.jetbrains.kotlinx:kotlinx-coroutines-core:0.11-rc"