Verify that functions were called

When using mocked dependencies, you usually want to test that your code calls the correct functions. In MockK, this is accomplished using the verify function.

Using verify to verify that a function was called looks a lot like using every for stubbing. A simple example is to call a method and immediately check that it was called.

  1. import io.mockk.every
  2. import io.mockk.mockk
  3. import io.mockk.verify
  5. val navigator = mockk<Navigator>()
  6. every { navigator.navigateTo(any()) } returns Unit
  8. navigator.navigateTo("Park")
  9. verify { navigator.navigateTo("Park") }

Similar to stubbing with every, verify starts a verification block and uses anonymous functions and infix functions to define what will be verified. verify supports the same argument matchers as every, along with a few additional matchers.

Inside the verification block (between the opening curly bracket { and closing curly bracket }), you write the method you want to verify. { navigator.navigateTo("Park") } tells MockK to check if the navigateTo method on the navigator object was called with the argument "Park".

Verifying dependencies

In the previous simple example, verification isn’t very helpful as it just checks that the previous line ran. Verification becomes more useful when you are testing other classes, that depend on mocked instances. Let’s start testing a button.

  1. class Button {
  2.   private var clickListener: (() -> Unit)? = null
  4.   fun setOnClickListener(listener: () -> Unit) {
  5.     clickListener = listener
  6.   }
  8.   fun performClick() {
  9.     clickListener?.invoke()
  10.   }
  11. }
  13. class NavigationView(
  14.   private val navigator: Navigator
  15. ) {
  17.   val goToParkButton = Button()
  19.   init {
  20.     goToParkButton.setOnClickListener {
  21.       navigator.navigate("Park")
  22.     }
  23.   }
  24. }

A test for the above NavigationView class should check that clicking the goToParkButton tells the navigator to go to the park. If the navigator doesn’t record where it goes, then it can be difficult to check that the button does its job correctly. This is a scenario where MockK can shine.

  1. // Mock the dependency needed for navigationView
  2. val navigator = mockk<Navigator>()
  3. every { navigator.navigateTo(any()) } returns Unit
  5. // Create the navigation view to test
  6. val navigationView = NavigationView(navigator)
  8. // Test the button in navigation view
  9. navigationView.goToParkButton.performClick()
  10. verify { navigator.navigateTo("Park") }

This test ensures that the button tells the navigator to go where we expect. If the NavigationView view gets changed in the future, the test will throw if this expectation is broken.

  1.     goToParkButton.setOnClickListener {
  2. -     navigator.navigate("Park")
  3. +     navigator.navigate("Parka")
  4.     }
  1. navigationView.goToParkButton.performClick()
  2. // Throws as navigateTo("Park") was never called.
  3. // MockK will mention in the error that navigateTo("Parka") was called.
  4. verify { navigator.navigateTo("Park") }

Verifying that any mock functions is never called

  1. verify { navigator wasNot Called }

Verifying that a function is never called

  1. verify(inverse = true) { navigator.navigateTo("Park") }
  2. verify(exactly = 0) { navigator.navigateTo("Park") }

Verifying a function is called a certain number of times

  1. verify(exactly = 1) { navigator.navigateTo("Park") }
  2. verify(atLeast = 1, atMost = 1) { navigator.navigateTo("Park") }

Using a range

  1. verify(atLeast = 2, atMost = 3) { navigator.navigateTo("Park") }

In the sample test will be green in the following cases:

  1. Function called two times
  2. Function called three times

Verifying multiple functions

TODO: ordering, verifyAll, verifySequence, verifyOrder

Confirming all calls were verified

TODO: confirmVerified, excludeRecords