MockK for mocking in Android Kotlin

Introduction

MockK helps you test your Android app by pretending parts of your code work a certain way. This way, you can check if your app behaves correctly without needing everything to be ready.

When you want to test a function that depends on another class without running the real code.

When you want to check if a method was called during a test.

When you want to simulate different responses from a service or database.

When you want to isolate a part of your app to find bugs easily.

When you want to speed up tests by skipping slow or complex operations.

Syntax

Android Kotlin

val mockObject = mockk<ClassName>()
every { mockObject.someMethod() } returns someValue
verify { mockObject.someMethod() }

mockk() creates a fake version of a class.

every { ... } returns ... sets what the fake should return when a method is called.

verify { ... } checks if a method was called during the test.

Examples

This creates a fake list and tells it to say its size is 3.

Android Kotlin

val mockList = mockk<MutableList<String>>()
every { mockList.size } returns 3

This fakes a service that returns "Hello" when getData() is called.

Android Kotlin

val mockService = mockk<Service>()
every { mockService.getData() } returns "Hello"

This checks if getData() was called on the fake service.

Android Kotlin

verify { mockService.getData() }

Sample App

This code creates a fake Calculator. It tells the fake to return 10 when add(2, 3) is called. Then it calls add(2, 3) and prints the result. Finally, it checks if add(2, 3) was called.

Android Kotlin

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

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

fun main() {
  val mockCalc = mockk<Calculator>()
  every { mockCalc.add(2, 3) } returns 10

  val result = mockCalc.add(2, 3)
  println("Result: $result")

  verify { mockCalc.add(2, 3) }
}

Important Notes

MockK works well with Kotlin and supports many features like spying and relaxed mocks.

Always verify important calls to make sure your code behaves as expected.

Use relaxed mocks if you want default values without specifying every behavior.

Summary

MockK creates fake objects to help test parts of your app separately.

You can tell fakes what to return and check if methods were called.

This makes testing easier, faster, and more reliable.

Practice

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

easy

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

B. To speed up the app's UI animations

C. To generate random data for the app

D. To compile Kotlin code faster

Solution

1. Step 1: Understand MockK's role

   MockK is a library used to create fake objects that imitate real objects in tests.

2. Step 2: Identify the main use

   This helps test parts of the app separately without relying on real implementations.

3. Final Answer:

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

4. Quick Check:

   MockK purpose = Fake objects for testing [OK]

Hint: MockK fakes objects to isolate tests quickly [OK]

Common Mistakes:

• Thinking MockK speeds up UI animations
• Confusing MockK with data generators
• Believing MockK affects compilation speed

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

easy

A. val mock = MockK<MyClass>()

B. val mock = mockk<MyClass>()

C. val mock = mock<MyClass>()

D. val mock = createMock<MyClass>()

Solution

1. Step 1: Recall MockK mock creation syntax

   MockK uses the function mockk<T>() to create mocks of type T.

2. Step 2: Match syntax to options

   val mock = mockk<MyClass>() matches the correct syntax exactly.

3. Final Answer:

   val mock = mockk<MyClass>() -> Option B

4. Quick Check:

   MockK mock creation = mockk<Type>() [OK]

Hint: Use mockk<Type>() to create mocks in MockK [OK]

Common Mistakes:

• Using capitalized MockK instead of mockk
• Using mock() which is from other libraries
• Trying createMock() which is not in MockK

3. Given the code snippet:

val mock = mockk<Calculator>()
every { mock.add(2, 3) } returns 5
val result = mock.add(2, 3)

What is the value of result?

medium

A. Throws an exception

B. 0

C. 5

D. 2

Solution

1. Step 1: Understand the mocking setup

   The line every { mock.add(2, 3) } returns 5 tells MockK to return 5 when add(2, 3) is called.

2. Step 2: Check the method call

   The call mock.add(2, 3) matches the mocked behavior, so it returns 5.

3. Final Answer:

   5 -> Option C

4. Quick Check:

   Mocked method returns set value = 5 [OK]

Hint: Mocked calls return specified values, not real logic [OK]

Common Mistakes:

• Expecting real method logic to run
• Assuming default 0 return for Int
• Thinking mock throws error without setup

4. What is wrong with this MockK code snippet?

val mock = mockk<UserService>()
verify { mock.getUser() }

medium

A. mockk<UserService>() is invalid syntax

B. getUser() method cannot be verified

C. verify requires a return value setup

D. verify is called before any method call on mock

Solution

1. Step 1: Understand verify usage

   The verify block checks if a method was called on the mock.

2. Step 2: Check method call timing

   Here, verify is called before mock.getUser() is ever called, so verification fails.

3. Final Answer:

   verify is called before any method call on mock -> Option D

4. Quick Check:

   Verify needs method call before checking [OK]

Hint: Call method before verify to avoid errors [OK]

Common Mistakes:

• Calling verify before method invocation
• Thinking verify needs return setup
• Believing all methods are unverifiable

5. You want to test a function that calls fetchData() on a mock and then processes the result. Which MockK feature lets you simulate fetchData() returning different values on consecutive calls?

hard

A. Using every with returnsMany

B. Using slot to capture arguments

C. Using andThen to chain return values

D. Using relaxed mocks to auto-return defaults

Solution

1. Step 1: Identify feature for multiple returns

   MockK's returnsMany allows specifying a list of return values for consecutive calls.

2. Step 2: Match feature to options

   Using every with returnsMany correctly pairs every with returnsMany to simulate different returns on calls.

3. Final Answer:

   Using every with returnsMany -> Option A

4. Quick Check:

   Multiple returns = every + returnsMany [OK]

Hint: Use returnsMany to mock multiple call results [OK]

Common Mistakes:

• Confusing andThen with returnsMany
• Using slot for return values instead of capturing
• Relying on relaxed mocks for varied returns