Testing Fundamentals: Unit Tests and UI Tests in Android with Kotlin

In software development, testing is a crucial process that ensures the quality and reliability of the application. In Android development, two essential types of tests are Unit Tests and UI Tests. This blog post will delve into these testing methodologies, highlighting their importance, how to implement them in Android using Kotlin, and the best practices to follow.

Unit Tests and UI Tests in Android with Kotlin

Before we dive into the specifics of Unit and UI testing, it’s essential to understand the overall testing landscape in Android. Testing in Android is typically divided into three broad categories:

Unit Tests: These tests focus on the smallest testable parts of an application, like functions or classes, ensuring they work correctly in isolation.Integration Tests: These tests check how different parts of the application work together, verifying their interactions and combined behavior.UI Tests: These tests simulate user interactions with the application, ensuring the user interface behaves as expected.

Unit and UI tests are the foundation of a robust testing strategy, balancing low-level checks and high-level user flow validations.

Understanding Unit Tests

Unit Testing involves testing individual components of the software independently to ensure they function as intended. In the context of Android development, this means testing classes and methods without involving the Android framework.

Benefits of Unit Testing

Early Bug Detection: Unit tests help identify issues early in the development cycle, reducing the cost and effort of fixing bugs.
Documentation: Well-written tests serve as documentation for the code, providing examples of how to use the methods and classes.
Refactoring Confidence: With a robust set of unit tests, developers can refactor code with confidence, knowing that any breaking changes will be caught by the tests.

Writing Unit Tests in Kotlin

In Android, we use JUnit for writing and running unit tests. Here’s a step-by-step guide to writing unit tests in Kotlin:

Setup the Testing Environment: Add the following dependencies to your build.gradle file:

testImplementation 'junit:junit:4.13.2'
testImplementation 'org.jetbrains.kotlin:kotlin-test-junit:1.5.10'

2. Create a Sample Class to Test: Let’s create a simple Calculator class:

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

    fun subtract(a: Int, b: Int): Int {
        return a - b
    }
}

3. Write Unit Tests

Now, create a test class for the Calculator:

import org.junit.Assert.assertEquals
import org.junit.Test

class CalculatorTest {

    private val calculator = Calculator()

    @Test
    fun testAdd() {
        val result = calculator.add(2, 3)
        assertEquals(5, result)
    }

    @Test
    fun testSubtract() {
        val result = calculator.subtract(5, 3)
        assertEquals(2, result)
    }
}

4. Run the Tests: You can run your tests from the command line using Gradle:

./gradlew test

Or directly from Android Studio by right-clicking the test class and selecting “Run”.

Best Practices for Unit Testing

Isolate Dependencies: Use mock objects to isolate the class under test from its dependencies.
Test All Edge Cases: Ensure your tests cover all possible edge cases and scenarios.
Keep Tests Independent: Each test should be independent and not rely on the state of other tests.
Write Readable Tests: Tests should be easy to read and understand, serving as documentation for the codebase.

Understanding UI Tests

UI Testing involves testing the user interface of the application to ensure that it behaves as expected from the user’s perspective. These tests simulate user interactions such as clicks, text input, and navigation.

Benefits of UI Testing

User Experience Validation: UI tests ensure that the application provides a smooth and functional user experience.
Regression Testing: Automated UI tests help catch regressions introduced by code changes, maintaining the application’s stability.
Confidence in Releases: Comprehensive UI tests provide confidence that the application works as intended, even after significant changes.

Writing UI Tests in Kotlin

In Android, we use Espresso for writing and running UI tests. Here’s a step-by-step guide to writing UI tests in Kotlin:

Setup the Testing Environment: Add the following dependencies to your build.gradle file:

androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'
androidTestImplementation 'androidx.test.ext:junit:1.1.3'

2. Create a Simple Activity to Test: Let’s create a simple activity with a button and a text view:

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val button = findViewById<Button>(R.id.button)
        val textView = findViewById<TextView>(R.id.textView)

        button.setOnClickListener {
            textView.text = "Button clicked"
        }
    }
}

activity_main.xml layout file:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp">

    <Button
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Click me" />

    <TextView
        android:id="@+id/textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="16dp"
        android:text="Hello World" />
</LinearLayout>

3. Write UI Tests: Now, create a test class for the MainActivity:

import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.rule.ActivityTestRule
import androidx.test.ext.junit.rules.ActivityScenarioRule
import androidx.test.espresso.Espresso.onView
import androidx.test.espresso.action.ViewActions.click
import androidx.test.espresso.matcher.ViewMatchers.withId
import androidx.test.espresso.matcher.ViewMatchers.withText
import androidx.test.espresso.assertion.ViewAssertions.matches
import org.junit.Rule
import org.junit.Test
import org.junit.runner.RunWith

@RunWith(AndroidJUnit4::class)
class MainActivityTest {

    @get:Rule
    val activityRule = ActivityScenarioRule(MainActivity::class.java)

    @Test
    fun buttonClick_changesText() {
        // Perform a click on the button
        onView(withId(R.id.button)).perform(click())

        // Check if the text view text has changed
        onView(withId(R.id.textView)).check(matches(withText("Button clicked")))
    }
}

4. Run the Tests: You can run your UI tests from the command line using Gradle:

./gradlew connectedAndroidTest

Or directly from Android Studio by right-clicking the test class and selecting “Run”.

Best Practices for UI Testing

Keep Tests Fast and Reliable: UI tests can be slower and more prone to flakiness. Ensure they run reliably and as quickly as possible.
Use Idling Resources: Use Espresso’s Idling Resources to handle asynchronous operations and ensure the UI is idle before interacting with it.
Test Realistic Scenarios: Simulate real user interactions and scenarios to validate the user experience effectively.
Separate Concerns: Separate the test setup, actions, and assertions for better readability and maintainability.

Conclusion

Unit tests and UI tests are essential components of a comprehensive testing strategy in Android development. Unit tests help ensure the correctness of individual components, while UI tests validate the overall user experience. By following best practices and leveraging tools like JUnit and Espresso, you can build robust, maintainable, and high-quality Android applications.

Implementing a solid testing strategy requires effort and discipline, but the payoff is significant. You’ll gain confidence in your code, reduce the number of bugs in production, and ultimately deliver a better experience to your users. Happy testing!

Table of Contents