A Beginner's Guide to Kotlin Unit Testing [With Examples]

OVERVIEW

As a tester, during your career, you’ll write and maintain tons of unit tests, integration tests, or E2E tests to help deliver a quality product. In practice, much focus is given to tools and knowledge around the E2E test suites. Getting a good grasp of unit testing concepts and championing the process to other engineers is pivotal to your effectiveness and success as an engineer.

Unit testing is one of the major pillars of any modern automated testing strategy. As called out in the practical test pyramid, it usually forms the largest no of tests for your application.

In this Kotlin unit testing tutorial, we'll focus on learning unit testing using the Kotlin programming language. The principles for solid unit testing apply not just in Kotlin language but can be extended to other languages and are very relevant to Java language.

What can you expect to gain by reading this Kotlin unit testing tutorial?

You'll leave with an understanding and a beginner's perspective of:

• What is unit testing?
• Why should we do unit testing?
• Learn how to set up a local environment for JVM Kotlin unit testing with IDE and project setup from scratch.
• Write your first unit test.
• Understand how to extract test coverage.

We'll start with just a basic idea of what unit testing is all about and quickly move on to practical hands-on stuff since this is one of the best ways to learn any new tool, technique, or technology. This Kotlin unit testing tutorial would also form the foundation for a series of other tutorials where we will go deep into unit testing with a focus on Mobile with Android and Backend. You can find the code used in this Kotlin unit testing tutorial on GitHub.

I'm very excited to share this journey with you. Let's begin.🏃

Mocking in Kotlin unit tests

So far, we've understood how to write JUnit5 tests for Kotlin unit testing and see its coverage.

Any discussion about Kotlin unit testing is incomplete without a mention of Mocking, and it's such an essential technique to understand to write scalable unit tests that only test the unit they are concerned with.

We will use the Mockito library to demonstrate this. There are many JVM libraries that support Mocking (such as wiremock and mockK), and each has its pros and cons. The mocking libraries API might be slightly different but the underlying semantics remain the same.

A typical test with mock may have below-high-level blocks.

• Setup the class to mock.
• Setup behavior, i.e., given certain inputs, what output should be returned.
• Cases that are not defined should return a default value.

Let's first set up Mockito in our build.gradle file.

You can find the complete build.gradle file below:

Gradle is an advanced build automation tool that provides a flexible and efficient way to automate the building, testing, and deployment processes of software projects. It is designed to handle projects of any size or complexity and supports multiple programming languages, including Java, Kotlin, Groovy, and more.

At its core, Gradle uses a build script written in Groovy or Kotlin, allowing developers to define and customize their build logic. The build script specifies the project structure, dependencies, tasks, and configurations required to build the software.

Understanding the unit under test

It's always better to use an example to understand concepts. Let's consider an eCommerce application wherein a user can make an order. If the product is present in sufficient quantity in the warehouse, then we are able to fulfill it.

You can find the application classes under io.automationhacks/ecommerce package.

In this example we have two classes:

package io.automationhacks.ecommerce


class Order(private val product: String, private val quantity: Int) {
private lateinit var warehouse: Warehouse
private var isFilled: Boolean = false


fun fill(warehouse: Warehouse) {
this.warehouse = warehouse
isFilled = this.warehouse.remove(product, quantity)
}


fun isFilled(): Boolean {
return isFilled
}
}

The order class refers to a warehouse class as a collaborator and tries to fill itself by removing a certain product in the desired quantity. Depending on the outcome of this operation, a boolean flag isFilled is set to indicate if the order was fulfilled or not.

Now let's take a look at the warehouse class.

package io.automationhacks.ecommerce


class Warehouse {
private val warehouse: HashMap<String, Int> = hashMapOf()
fun add(product: String, quantity: Int) {
warehouse[product] = quantity
}


fun remove(product: String, quantity: Int): Boolean {
if (warehouse.contains(product).not()) {
println("Product not found in warehouse")
return false
}


if (warehouse[product] == 0) {
println("No items for this product in the warehouse")
return false
}


if (warehouse[product]!! < quantity) {
println("Not enough items in the warehouse")
return false
}


val currentQty = warehouse[product]
val newQty = currentQty!!.minus(quantity)
warehouse[product] = newQty
return true
}


fun getInventory(product: String): Int? {
return warehouse.get(product)
}
}

The warehouse class maintains a hashmap of the product and its current quantity. It exposes a couple of APIs to add items to the warehouse using the add() method and remove().

The remove() method also does a bunch of checks and returns a false in case we are not able to remove items from the warehouse. Finally, we also write a getInventory() method to allow the caller to know the current state of the warehouse.

Write a test to verify state

What would a simple unit test for these classes look like?

Let's take a look.

package io.automationhacks.ecommerce


import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import kotlin.test.assertEquals
import kotlin.test.assertFalse
import kotlin.test.assertTrue


class OrderStateTest {
private val LAPTOP = "Macbook"
private val MOUSE = "Logitech Mouse"
private val warehouse = Warehouse()


@BeforeEach
fun setUp() {
warehouse.add(LAPTOP, 50)
warehouse.add(MOUSE, 20)
}


@Test
fun 'test order is fulfilled if capacity in warehouse is sufficient'() {
val order = Order(LAPTOP, 20)
order.fill(warehouse)
assertTrue(order.isFilled())
assertEquals(30, warehouse.getInventory(LAPTOP))
}


@Test
fun 'test order is not fulfilled if capacity in warehouse is insufficient'() {
val order = Order(MOUSE, 21)
order.fill(warehouse)
assertFalse(order.isFilled())
assertEquals(20, warehouse.getInventory(MOUSE))
}


}

In the above test

• To ensure consistent test execution, we incorporate new items into the warehouse before each test. This is achieved by annotating the setUp() method with @BeforeEach. You can learn more about it through this blog on annotations in JUnit.
• Next, we wrote a couple of tests
• For a positive scenario, we perform a test where we attempt to fulfill an order when the warehouse contains an adequate quantity of the product.
• To cover a negative scenario, we conduct a test specifically designed to check the situation when the warehouse does not possess the required product in sufficient quantity.

There could be even more tests written just for these classes but that is an exercise that is left up to you.

Writing test with mock

Now, let's see how we can use Mockito with JUnit to write mocks for these classes and scenarios. In this example, we are interested in testing the order class and will mock out its collaborators, i.e., Warehouse.

This also allows us to verify different behaviors around Warehouse and their impact on the order class.

package io.automationhacks.ecommerce


import org.junit.jupiter.api.Test
import org.mockito.Mockito.*
import kotlin.test.assertEquals
import kotlin.test.assertFalse
import kotlin.test.assertTrue


class OrderInteractionTest {
private val LAPTOP = "Macbook"


@Test
fun 'test warehouse capacity is reduced on fulfilling order'() {
val order = Order(LAPTOP, 50)
val warehouseMock = mock(Warehouse::class.java)


'when'(warehouseMock.getInventory(LAPTOP)).thenReturn(0)
'when'(warehouseMock.remove(LAPTOP, 50)).thenReturn(true)


order.fill(warehouseMock)
assertTrue(order.isFilled())
assertEquals(0, warehouseMock.getInventory(LAPTOP))
}


@Test
fun 'test warehouse capacity is not reduced when order cannot be fulfilled'() {
val order = Order(LAPTOP, 51)
val warehouseMock = mock(Warehouse::class.java)
'when'(warehouseMock.getInventory(LAPTOP)).thenReturn(50)
'when'(warehouseMock.remove(LAPTOP, 50)).thenReturn(false)


order.fill(warehouseMock)
assertFalse(order.isFilled())
assertEquals(50, warehouseMock.getInventory(LAPTOP))
}
}

We have a couple of tests in the above class.

Let's unpack the first one (test warehouse capacity is reduced on fulfilling order) to understand how mocking with Mockito works.

We create a test order with the LAPTOP product and 50 quantities.

We call our fill method on the order class

And then assert that we indeed see the correct behavior.

Let's run the tests using the following command:

./gradlew test

We can see that all the tests passed.

We can follow the same pattern to also write a negative test with mocks. It's up to you to follow through with the test and attempt to write one.

This is a first look into understanding how a JUnit test case works E2E with mocking. There are multiple other operations provided by Mockito if you want to grasp different types of mocking strategies conceptually.

To harness the real power of Kotlin unit testing, it is recommended to run your Kotlin test cases on a cloud-based grid and avoid the challenges of setting up a local grid. Digital experience testing platform like LambdaTest lets you perform Kotlin unit testing with Appium at scale. LambdaTest offers a real device cloud to test Android applications in real-user conditions and get accurate test results.

Conclusion

Now that you have gained the knowledge to establish a fundamental unit test in the Kotlin JVM environment, you are well-equipped to proceed. Kotlin unit testing encompasses many aspects, and in our upcoming follow-up posts, we will delve deeper into specific focus areas.

To explore further, you can access the code sample for this post on our GitHub repository. Stay tuned for more valuable insights and techniques in the realm of Kotlin unit testing!

Delve into our top Unit Testing Interview Questions guide, designed to help you excel in unit testing interviews. It covers a wide range of topics, from syntax to advanced techniques, with detailed solutions.