Testing a function that creates a coroutine scope inside it

Question

I have something like the following in Kotlin:

class A {
    fun a(): Unit = TODO()
}
fun foo(a: A) {
    // Do something
    CoroutineScope(Dispatchers.IO).launch { 
      delay(1000)
      a.a() 
    }
    // Do something else
}

I want to write a test that verifies that the method A.a() was called by foo():

class MyTest {
  @Test
  fun `weird test`() {
    val mockA: A = mockk(relaxed = true)

    foo(mockA)

    verify(exactly = 1) { mockA.a() }
  }
}

Clearly, the test is failing because it is not synchronized with the coroutine. I tried to use runTest, but foo() is not a suspending function, and it is hiding the creation of the scope inside it.

What can I do?

Answer 1

Pass CoroutineDispatcher to the tested method instead of creating them inside the tested method.

You can create a controllable CoroutineDispatcher - StandardTestDispatcher(this.testScheduler) using coroutineScope provided by runTest.
And explicitly complete all coroutines on the test dispatcher - advanceUntilIdle() before running your verifications or assertions.

class MyTest {
    @Test
    fun `weird test`() = runTest {
        val mockA: A = mockk(relaxed = true)

        foo(mockA, StandardTestDispatcher(this.testScheduler))

        advanceUntilIdle()
        verify(exactly = 1) { mockA.a() }
    }
}

class A {
    fun a(): Unit = TODO()
}

fun foo(a: A, dispatcher: CoroutineDispatcher) {
    // Do something
    CoroutineScope(dispatcher).launch {
        delay(1000)
        a.a()
    }
    // Do something else
}

Also you can pass CoroutineScope instead of CoroutineDispatcher.
But note that CoroutineScope gives access to coroutines lifecycle (e.g. it could be used to cancel coroutines)

So:

• If the caller needs to control the lifecycle of coroutines launched by the function, then pass a CoroutineScope to the function.
• If the function should not expose direct access to its own coroutine lifecycle, then pass a CoroutineDispatcher and create CoroutineScope inside the function.

The issue usually addressed in Android development:

• Inject Dispatchers
• Inject TestDispatchers in tests
• Injecting a scope

Answer 2

Use Awaitility to poll until the async launch finishes, then assert:

Assuming you use Gradle with Kotlin DSL:

testImplementation("org.awaitility:awaitility-kotlin:4.3.0")

Then do:

class MyTest {
    @Test
    fun `weird test`() {
        val mockA: A = mockk()

        foo(mockA)

        await.atMost(Duration.ofSeconds(1)).untilAsserted {
            verify(exactly = 1) { mockA.a() }
        }
    }
}

However injecting a Dispatcher is a better way to do this as mentioned in this answer.