Mocking with MockK in Kotlin - Mini Project: Build & Apply

Mocking with MockK

📖 Scenario: You are writing tests for a simple calculator app. You want to check how your code behaves when the calculator service returns specific results without calling the real service.

🎯 Goal: Learn how to use MockK to create a mock of a calculator service, configure its behavior, and verify the output of a function that uses this service.

📋 What You'll Learn

Create an interface called CalculatorService with a function add(a: Int, b: Int): Int

Create a mock of CalculatorService using MockK

Configure the mock to return a specific value when add is called with certain arguments

Call the add function on the mock and print the result

💡 Why This Matters

🌍 Real World

Mocking helps you test your code without relying on real services or complex dependencies. This makes tests faster and more reliable.

💼 Career

Many software development jobs require writing unit tests. Knowing how to use mocking libraries like MockK is essential for testing Kotlin applications effectively.

1

Create the CalculatorService interface

Create an interface called CalculatorService with a function add(a: Int, b: Int): Int.

Kotlin

// Create interface CalculatorService with add function
// Your code here

Hint

Use the interface keyword and define the add function with two Int parameters and an Int return type.

2

Create a mock of CalculatorService

Create a variable called mockCalculator and assign it a mock of CalculatorService using mockk().

Kotlin

interface CalculatorService {
    fun add(a: Int, b: Int): Int
}

// Create mockCalculator as a mock of CalculatorService
// Your code here

Hint

Use val mockCalculator = mockk<CalculatorService>() to create the mock.

3

Configure the mock behavior

Use every { mockCalculator.add(2, 3) } to return 5.

Kotlin

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

interface CalculatorService {
    fun add(a: Int, b: Int): Int
}

val mockCalculator = mockk()

// Configure mockCalculator.add(2, 3) to return 5
// Your code here

Hint

Use every { mockCalculator.add(2, 3) } returns 5 to set the mock's return value.

4

Call the mock and print the result

Call mockCalculator.add(2, 3) and print the result using println.

Kotlin

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

interface CalculatorService {
    fun add(a: Int, b: Int): Int
}

val mockCalculator = mockk()
every { mockCalculator.add(2, 3) } returns 5

// Call mockCalculator.add(2, 3) and print the result
// Your code here

Hint

Call mockCalculator.add(2, 3), store it in result, then print result.

Practice

1. What is the main purpose of using MockK in Kotlin testing?

easy

A. To create fake objects that simulate real ones for testing

B. To compile Kotlin code faster

C. To write UI layouts

D. To deploy Kotlin applications

Solution

1. Step 1: Understand mocking concept

   Mocking means creating fake versions of objects to test code without using real dependencies.

2. Step 2: Identify MockK's role

   MockK is a Kotlin library that helps create these fake objects easily for testing purposes.

3. Final Answer:

   To create fake objects that simulate real ones for testing -> Option A

4. Quick Check:

   MockK = mocking tool for fake objects [OK]

Hint: MockK is for faking objects in tests [OK]

Common Mistakes:

• Confusing MockK with build or deployment tools
• Thinking MockK is for UI design
• Assuming MockK speeds up compilation

2. Which of the following is the correct way to create a mock of a class MyService using MockK?

easy

A. val mock = new MyService()

B. val mock = MockK<MyService>()

C. val mock = mockk<MyService>()

D. val mock = createMock<MyService>()

Solution

1. Step 1: Recall MockK syntax for mocking

   MockK uses the function mockk<ClassName>() to create mocks.

2. Step 2: Check each option

   val mock = mockk<MyService>() uses mockk<MyService>(), which is correct syntax. Others are invalid or not MockK functions.

3. Final Answer:

   val mock = mockk<MyService>() -> Option C

4. Quick Check:

   mockk<Class>() creates mock [OK]

Hint: Use mockk<Class>() to create mocks [OK]

Common Mistakes:

• Using uppercase 'MockK' as a function
• Trying to use 'new' keyword in Kotlin
• Using non-existent functions like createMock

3. Given the following code snippet, what will be printed?

val mock = mockk<Calculator>()
every { mock.add(2, 3) } returns 10
println(mock.add(2, 3))
println(mock.add(1, 1))

medium

A. 10
Exception

B. 10
0

C. 10
null

D. 5
0

Solution

1. Step 1: Understand mocking behavior setup

   The mock is told to return 10 when add(2, 3) is called.

2. Step 2: Check calls and outputs

   Calling mock.add(2, 3) returns 10 as set. Calling mock.add(1, 1) has no behavior defined, so MockK throws an exception by default.

3. Final Answer:

   10 Exception -> Option A

4. Quick Check:

   Defined call returns 10; undefined call throws exception [OK]

Hint: Undefined mock calls throw exceptions by default [OK]

Common Mistakes:

• Assuming undefined calls return 0 or null
• Thinking all calls return the same mocked value
• Ignoring that MockK throws exceptions on undefined calls

4. Identify the error in this MockK usage:

val mock = mockk<UserRepository>()
every { mock.getUser(any()) } returns User("Alice")
mock.getUser(1)
verify { mock.getUser(1) }

medium

A. Missing relaxed = true when creating mock

B. No error; code is correct

C. No verify block needed after calling mock

D. Incorrect use of any() matcher in every

Solution

1. Step 1: Analyze mocking and stubbing

   The mock is created normally, and every sets behavior for any argument using any(), which is valid.

2. Step 2: Check verification usage

   After calling mock.getUser(1), the verify block correctly checks that the method was called with argument 1.

3. Final Answer:

   No error; code is correct -> Option B

4. Quick Check:

   any() matcher and verify block used correctly [OK]

Hint: any() matcher works inside every; verify checks calls [OK]

Common Mistakes:

• Thinking relaxed=true is always required
• Confusing verify usage with unnecessary calls
• Misusing any() matcher outside stubbing

5. You want to mock a Kotlin interface PaymentProcessor so that calling process(amount) returns "Success" only when amount is greater than 100, otherwise throws an exception. Which MockK setup achieves this?

hard

A. every { mock.process(match { it > 100 }) } returns "Success"
every { mock.process(match { amount <= 100 }) } throws IllegalArgumentException()

B. every { mock.process(any()) } returns "Success"

C. every { mock.process(100) } returns "Success"
every { mock.process(0) } throws IllegalArgumentException()

D. every { mock.process(gt(100)) } returns "Success"
every { mock.process(ltEq(100)) } throws IllegalArgumentException()

Solution

1. Step 1: Understand conditional mocking with matchers

   MockK supports argument matchers like gt() (greater than) and ltEq() (less than or equal) for conditions.

2. Step 2: Evaluate options for correct matcher usage

   every { mock.process(gt(100)) } returns "Success" every { mock.process(ltEq(100)) } throws IllegalArgumentException() correctly uses gt(100) to return "Success" and ltEq(100) to throw exception, matching the requirement precisely.

3. Final Answer:

   every { mock.process(gt(100)) } returns "Success" every { mock.process(ltEq(100)) } throws IllegalArgumentException() -> Option D

4. Quick Check:

   Use gt() and ltEq() for conditional mocking [OK]

Hint: Use gt() and ltEq() matchers for numeric conditions [OK]

Common Mistakes:

• Using match { } lambda instead of built-in matchers
• Mocking only specific values, missing ranges
• Returning success for all inputs ignoring conditions