Mocking with MockK in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this MockK verification?

Consider the following Kotlin code using MockK. What will be printed?

Kotlin

import io.mockk.mockk
import io.mockk.verify

class Calculator {
    fun add(a: Int, b: Int): Int = a + b
}

fun main() {
    val calc = mockk<Calculator>(relaxed = true)
    calc.add(2, 3)
    verify { calc.add(2, 3) }
    println("Verification passed")
}

A Compilation error: missing import

B Verification passed

C io.mockk.MockKException: no calls found for: Calculator#add(2, 3)

D Runtime error: NullPointerException

💡 Hint

Think about what relaxed = true means for the mock.

Because the mock is relaxed, calling add(2, 3) does not throw an error and the call is recorded. The verify confirms the call happened, so "Verification passed" is printed.

❓ Predict Output

intermediate

What happens when verifying a call that did not happen?

What error will this code produce?

Kotlin

import io.mockk.mockk
import io.mockk.verify

class Service {
    fun fetchData(): String = "data"
}

fun main() {
    val service = mockk<Service>()
    verify { service.fetchData() }
}

A io.mockk.MockKException: no calls found for: Service#fetchData()

B Compilation error: verify requires a block

C No output, verification passes silently

D Runtime error: NullPointerException

💡 Hint

What happens if you verify a call that was never made?

Since fetchData() was never called on the mock, verify throws a MockKException indicating no calls found.

🔧 Debug

advanced

Why does this MockK stub not work as expected?

Look at this Kotlin code snippet. The stub is supposed to return 10 when compute() is called, but it returns 0 instead. Why?

Kotlin

import io.mockk.mockk
import io.mockk.every

class Processor {
    fun compute(): Int = 5
}

fun main() {
    val processor = mockk<Processor>()
    every { processor.compute() } returns 10
    println(processor.compute())
}

A The mock is not relaxed, so it returns default Int value 0 instead of 10

B The stub is correct; the output will be 10

C The mockk library is not imported correctly, causing default return

D The stub is ignored because compute() is final and cannot be mocked

💡 Hint

Consider Kotlin's default behavior for functions and MockK's handling of final methods.

By default, Kotlin functions are final. MockK cannot mock final methods unless the class or method is open or the mockk agent is configured. Here, compute() is final, so the stub is ignored and the default Int value 0 is returned.

📝 Syntax

advanced

Which option correctly mocks a suspend function with MockK?

Given a suspend function suspend fun fetch(): String, which code correctly mocks it to return "hello"?

A every { runBlocking { mock.fetch() } } returns "hello"

B coVerify { mock.fetch() } returns "hello"

C coEvery { mock.fetch() } returns "hello"

D every { mock.fetch() } returns "hello"

💡 Hint

MockK has special functions for suspend functions.

For mocking suspend functions, coEvery is used to stub the call. Option C uses coEvery correctly. Option C misuses every with runBlocking. Option C uses every which does not work with suspend functions. Option C uses coVerify which is for verification, not stubbing.

🚀 Application

expert

How many times was the function called?

Given this code, how many times was service.process() called?

Kotlin

import io.mockk.mockk
import io.mockk.verify

class Service {
    fun process() {}
}

fun main() {
    val service = mockk<Service>(relaxed = true)
    service.process()
    service.process()
    service.process()
    verify(exactly = 2) { service.process() }
}

A 3 times, but verification expects 2, so it throws an exception

B 2 times, verification passes

C 1 time, verification fails

D 0 times, verification fails

💡 Hint

Count the calls and compare with the verification count.

The function process() is called 3 times, but the verification expects exactly 2 calls. This mismatch causes MockK to throw a MockKException.