Recientemente me convertí en un fan de Android Kotlin y me convertí. Luego leí sobre las corrutinas y pensé que todas mis Navidades geek habían llegado a la vez.

Corutinas

Las corrutinas en Kotlin permiten tareas asincrónicas sencillas. Con unas pocas líneas podemos realizar llamadas asincrónicas y obtener su respuesta

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

• La clase de Android es el código de Miguel Castiblanco directamente de esta excelente publicación
• asyncTask es una función auxiliar que he escrito para reducir el código y hacer las cosas un poco más ordenadas.

Prueba de unidad

Ahora queremos hacer una prueba unitaria del método getListOfThings . Primero tenemos el problema de la burla de que las clases y métodos de Kotlin son definitivos por defecto. No está mal (ábrelos o usa las últimas funciones de Mockito para burlarse del final).

En mi implementación asíncrona anterior (RxJava), puede cambiar fácilmente los programadores para la prueba, convirtiéndolo en asíncrono en síncrono para fines de prueba. Esto resultó imposible usando corrutinas.

En cambio, tuve que adoptar un enfoque diferente ... primero, escriba una prueba unitaria 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()
}

Lo que tenemos que hacer es mover la sección de lanzamiento (Android) fuera del presentador, para que podamos probar solo la lógica. Pero no queremos que se llame al método del presentador en el subproceso de la interfaz de usuario.

Ingrese la palabra clave suspend y ejecuteBlocking :

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

Se obtiene el mismo error dentro de la prueba, por lo rodean a la llamada a la getListOfThings método con runBlocking .

Si ejecutamos la prueba ahora, todo verde ... ¡yay!

Configuración de Kotlin

Las corrutinas solo están disponibles en Kotlin 1.1, que (al momento de escribir este artículo) está en RC.

Deberá configurar su proyecto para usar 1.1 y luego agregar la siguiente importación

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