MockK for mocking in Android Kotlin - Build, Publish & Deploy

Build & Publish - MockK for mocking

Performance Impact

Using MockK in your Android Kotlin tests does not affect your app's runtime performance or battery life because mocks are only used during testing, not in the released app. However, complex mocks or many mocks can slow down test execution time and increase memory use during testing.

Optimization Tips

To keep tests fast and efficient, create only the mocks you need and avoid unnecessary stubbing. Use relaxed mocks when possible to reduce setup code. Run tests in parallel if your CI supports it. Avoid heavy initialization inside mocks to keep test memory low and speed high.

App Size Impact

MockK is a testing library and is not included in your app's release build. It does not increase your app bundle size or startup time. Make sure to include MockK only in your test dependencies to keep your app size small.

iOS vs Android Differences

MockK is designed for Kotlin and Android testing. iOS uses different mocking tools like XCTest or third-party Swift mocking libraries. Android requires adding MockK as a test dependency in Gradle, while iOS uses Xcode and Swift Package Manager or CocoaPods for test libraries.

Store Review Guidelines

Since MockK is only used in testing, it does not affect app store guidelines. Ensure your release build excludes test libraries like MockK. For Android, use the testImplementation configuration in Gradle to avoid packaging test code. For iOS, test code must not be included in the app bundle.

Self-Check

Your app takes 5 seconds to load this screen. What's likely wrong?

• You might be running tests or mocks in the release build by mistake, increasing startup time.
• Test dependencies like MockK are accidentally included in the app bundle.
• Mocks are used in production code instead of real implementations.

Key Result

MockK is a Kotlin testing library that does not affect app runtime performance or size when properly excluded from release builds. Optimize test speed by limiting mocks and stubs. Ensure test libraries are only in test dependencies to comply with store guidelines.

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