How can you verify a suspend function call using `Matchers.anyObject()` in Mockito when testing coroutines?

General Discussions
, ,
1

When working with Kotlin coroutines, verifying suspend function calls in unit tests can sometimes trigger an InvalidUseOfMatchersException. For example, using verify(myInterface).makeNetworkCall(Matchers.anyObject()) inside a runBlocking block may cause issues because Mockito expects all parameters to be matched correctly.

The challenge usually lies in how Matchers.anyObject() interacts with Kotlin’s type system in suspend functions. Developers often explore alternatives like any() from org.mockito.kotlin or proper coroutine test utilities to ensure verification works as expected while testing asynchronous behavior.

2

When testing Kotlin coroutines, one thing I’ve learned over time is to avoid using Matchers.anyObject() for verifying suspend function calls, it often leads to InvalidUseOfMatchersException because it doesn’t gel well with Kotlin’s type system. Instead, I recommend using any() from org.mockito.kotlin. It’s more Kotlin-friendly and handles the type inference seamlessly, especially when working with coroutines. Here’s how you can write it:

runBlocking {
    verify(myInterface).makeNetworkCall(any())
}

This will help you sidestep the issues with mockito anyobject, making the tests cleaner and more reliable.

3

You’re right about that error! It happens because Matchers.anyObject() is a Java-style matcher, and it doesn’t support the nullable types that Kotlin expects in suspend functions. When working with coroutines, switching to MockitoKt.any() from org.mockito.kotlin is a great fix. Here’s how you can rewrite the test:

verify(myInterface).makeNetworkCall(MockitoKt.any())

Also, don’t forget to ensure your test runs inside a runBlocking or runTest coroutine scope. This keeps everything in line with Kotlin’s asynchronous behavior and gets rid of the mockito anyobject mismatch.

4

Great points so far! If you’re dealing with an overloaded suspend function or one that expects non-null arguments, you may need to be more specific. This happens because mockito anyobject might not be able to figure out the exact type, especially when dealing with coroutines. To fix that, specify the type explicitly like so:

verify(myInterface).makeNetworkCall(any<MyRequestType>())

By doing this, you avoid ambiguity between coroutines and the generic matchers. It ensures that your verification is not only type-safe but also coroutine-friendly, making it a smooth experience for both you and Mockito.