How do I test Kotlin coroutines inside a function?

Question

I am creating a library and I'm using Retrofit with a call-adapter that gives me a Deferred<> value.

In a function in my code I call launch {}, and inside that i try-catch the values, and possible exceptions - calling different callbacks for different results.

The resources I've found on testing coroutines are all about testing suspended functions, and runBlocking {} is the solution to everything. Except for me it isn't

I made a quick example

    @Mock
val mockListener: DoSomething.Listener = mock()

@Test
fun testSomething() {
    val doer = DoSomething(mockListener)
    runBlocking {
        doer.doIt()
        verify(mockListener).listen(any())
    }
}

class DoSomething(val listener: Listener) {

    interface Listener {
        fun listen(s: String)
    }

    fun doIt() {
        launch {
            listener.listen(theThing().await())
        }
    }

    private fun theThing(): Deferred<String> {
        return async {
            delay(5, TimeUnit.SECONDS)
            return@async "Wow, a thing"
        }
    }
}

What I want is for the actually run all functions. The test should take 5 seconds minimum, but it just runs through the code in a couple of millisconds- ie. it doesn't block.

I've tried adding

runBlocking {
    launch {
        // doer.doIt()
    }.joinChildren()
}

And similar practices but I just can't get the test to actually wait for my launch inside of another class to finish before the test is finished. Placing the verify(...) outside of the runBlocking also makes the test fail, which it should.

Any input, helpers, good practice etc. is appreciated!

Brais Gabin · Accepted Answer · 2019-02-20 17:23:17Z

4

You can provide the CoroutineContext explicitly for your doIt() function:

fun doIt(context: CoroutineContext = DefaultDispatcher) {
    launch(context) {
        listener.listen(theThing().await()
    }
}

With this parameter you could easily change the coroutine context - in your test code you use the blocking context:

runBlocking {
    doer.doIt(coroutineContext)
}

BTW: You don't need to use launch and async. With launch you are in a suspendable context and you don't need to run theThing() asynchronously. Especially if you invoke await() in the next step:

fun doIt(context: CoroutineContext = DefaultDispatcher) {
    launch(context) {
        listener.listen(theThing())
    }
}

private suspend fun theThing(): String {
    delay(5, TimeUnit.SECONDS)
    return "Wow, a thing"
}

edited Feb 20, 2019 at 17:23

Brais Gabin

5,9237 gold badges60 silver badges96 bronze badges

answered Aug 15, 2018 at 12:07

Rene

6,34820 silver badges22 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Yokich Over a year ago

facepalm Thank you! I shouldn't of course wrap the functionality in a launch, I should make the function suspend and launch the function. That's how you make it testable. (I don't agree with sending in the coroutineContext, that's seems kind'a weird. But suspend is definitely the way to go for testability!

Alexey Soshin · Accepted Answer · 2018-08-15 11:06:07Z

2

Best way would be not to swallow Job in your doIt() function as you do now.
Instead of

fun doIt() {
    launch {
        listener.listen(theThing().await())
    }
}

Do

fun doIt() = launch {
        listener.listen(theThing().await())
    }

That way your function will return a coroutine, which you can wait for:

doIt().join()

Better still is to use async() instead of launch()

Another comment is that doIt() should be actually doItAsync(), as suggested by Kotlin guidelines.

answered Aug 15, 2018 at 11:06

Alexey Soshin

17.9k2 gold badges37 silver badges42 bronze badges

Collectives™ on Stack Overflow

How do I test Kotlin coroutines inside a function?

2 Answers 2

1 Comment

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Related