suspendCoroutine is not testtable

Consider following scenario

Function to test:

fun execute(appConfig: AppConfig): Deferred<String> = async {
   registerDevice(appConfig.serviceId)    
}

private suspend fun registerDevice(serviceId: String): String = suspendCoroutine {
   //some nasty 3rd party library delivering data in a callback
   lib.registerDeviceForService(object: Callback {
          override fun onSuccess(response) {
             it.resume(response.data)
          }
      }
   )
}

Here is the test:

    private val callbackCaptor = argumentCaptor<Callback<Response>>()

    @Test
    fun `ok result of registration results in success`() = blocking {
        val deferred = classToTest.execute(appConfig)
        mockRegisterResponseSuccess()
        val result = deferred.await()
        result.should.be.equal(trackingId)
    }
 
    private fun mockRegisterResponseSuccess(result: ApiResponseStatus) {
        then(lib).should().registerDeviceForService(callbackCaptor.capture())
        callbackCaptor.firstValue.onSuccess(Response(data = "testdata"))
    }

suspendCoroutine blocks the call and code never gets to the mockRegisterReponseSuccess call to mock and capture the callback

[itsymbal]

for posterity: using MockK you can write something like this val lib: Lib = mockk() val slot = slot<LibCallback>() every { lib.doStuff(capture(slot)) } answers { slot.captured.onResultReady(“result ready”) }

[qwwdfsad]

  @Test
    fun `executes and gets result`() = blocking {
        val result = classToTest.execute().await()
        then(lib).should().doStuff(libCallbackCaptor.capture())
        libCallbackCaptor.firstValue.onResultReady("result ready")
                result.should.be.equal("result ready")

    }

Why are you expecting this test to work? You call await (suspending the whole coroutine) and then when deferred is complete, you are mocking the service which is supposed to complete deferred. That’s exactly the case I’ve described above with CompletableFuture. You should first mock the service and only then call await on it.

About mocking Kotlin code – it’s not a kotlinx.coroutines issue, just use a Kotlin-mockito.

Task is to test that calling testClassInstance.execute() returns back “result ready”

Something like this modulo proper mocking

 @Test
    fun sampleTest() = runTest {
        val lib = mock(Lib::class.java)
        val testInstance = TestClass(lib)
        Mockito.`when`(lib.doStuff(ArgumentMatchers.any(LibCallback::class.java))).thenAnswer { invocation -> (invocation.getArgument(0) as LibCallback).onResultReady("result ready") }
        val deferred = testInstance.execute()
        assertEquals("result ready", deferred.await())
    }