Is there a way of extracting the `Continuation` of a suspending function to later inject values (`.r...

# coroutines

[Stephen Edwards]

Is there a way of extracting the Continuation of a suspending function to later inject values (.resume()) on it to facilitate mocking of a similar pattern to mocking a function returning a `Single`/`Observable` with an RxRelay that is exposed to the test?

[Stephen Edwards]

e.g.,

mock.`when`(suspendingFunction()).thenReturn {
  suspendCoroutine<T> { continuation ->
    testScopeVariable = continuation  // <-- exposing this for later resumption 
  }
}

[Stephen Edwards]

this with a Mockito paradigm not MockK

[Stephen Edwards]

The mockito-kotlin style calling mocking mechanism for suspend functions can be inferred from this work here - https://github.com/nhaarman/mockito-kotlin/pull/357/

[Stephen Edwards]

the problem I am having is that the call of the mocked suspending function is still returning null not suspending waiting for my resumption of the exposed continuation

[Stephen Edwards]

the key here is I want to control when in the test the mocked coroutine resumes with it's value. I don't want it to be a list of values that can be returned immediately whenever the mock is called, but rather something I can trigger in the test

[Stephen Edwards]

@elizarov I know you helped with the mockito-kotlin attempt by neworld - any ideas here?

[elizarov]

Your mocked suspending function should return COROUTINE_SUSPENDED in this case. More details on how it all works internally are here: https://github.com/Kotlin/KEEP/blob/master/proposals/coroutines.md#implementation-details

[wasyl]

We have this in our project and I believe it works as expected

infix fun <T> OngoingStubbing<T>.willAnswer(block: suspend () -> T) =
    doAnswer(Answer {
        val rawInvocation = it as InterceptedInvocation

        @Suppress("UNCHECKED_CAST") // <https://github.com/nhaarman/mockito-kotlin/issues/346>
        val continuation = rawInvocation.rawArguments.last() as Continuation<T?>

        suspend { block() }.startCoroutineUninterceptedOrReturn(continuation)
    })

[Stephen Edwards]

Thanks I will read and try that

[Stephen Edwards]

@wasyl do you expose the continuation in a manner similar to the pseudo-code I wrote above?

[wasyl]

Something like

val subject = CompletableDeferred<Unit>()
val mock = mock<SomeInterface> {
    onBlocking { suspendFunction() } willAnswer { subject.await() }
}

Just the suspended function needs to be called in a different scope than the test, otherwise you’d get a deadlock

[wasyl]

(btw we found it makes more sense to not push values to coroutines like this, just mock them normally)

[Stephen Edwards]

thanks for the example and wisdom. Do you use time control then to manage the timing rather than immediate return? i.e. say you were testing some loading state

[wasyl]

Ah yes, loading state is exactly what this is useful for 😄

[Stephen Edwards]

otherwise yes I get that direct value mocks will be preferred 🙂