How to do Unit Testing Using Mockito in Android

Quick Summary

Unit Testing Using Mockito in Android, facilitated by Mockito, is crucial for ensuring code reliability. Beginning with setting up Mockito dependencies in the project’s build. gradle file, the process involves writing comprehensive test classes for targeted components like activities or presenters. Mockito’s functionality shines through in mocking dependencies, enabling isolated testing of components. Stubbing method calls aid in simulating various scenarios, while Mockito’s verification capabilities ensure method calls are as expected. Handling asynchronous operations, inherent in Android development, is simplified with Mockito’s support. Ultimately, executing tests via Android Studio’s test runner or Gradle validates code correctness, enhancing the overall robustness of Android applications.

What is Unit Testing?

In today’s world, as mobile applications grow more intricate, it’s vital to subject them to thorough testing to catch any potential bugs early on. Unfortunately, this crucial step is sometimes overlooked or sidelined by developers! To ensure that our code is easily testable, it’s essential to employ robust architectures like MVP or MVVM, which help maintain organization within our Android projects.

When it comes to testing, there are three primary categories to consider integrating into our testing arsenal:

1. UI Tests: These tests focus on verifying the functionality of our app’s user interface elements, such as buttons and screens. Typically, tools like Espresso are employed for this purpose.

2. Instrumented Tests: These tests run on real Android devices or emulators to validate that the app behaves correctly when users interact with it. Commonly used tools include AndroidX Test and Espresso.

3. Unit Tests: These tests are the backbone of our testing strategy, as they meticulously examine individual components of our code to ensure their proper functioning. For unit testing, developers often turn to tools like JUnit, Mockito, or Hamcrest.

The ultimate aim of Unit Testing is to catch and rectify bugs at an early stage, preventing them from escalating into significant issues down the line. In this tutorial, we’ll explore the world of Mockito in Android and uncover effective strategies for leveraging it to test our Android applications with precision.

What do you mean by Mockito?

Mockito, an essential tool for Android App Performance Optimization, empowers software developers to rigorously test their code. Picture building a complex Lego model, verifying individual pieces without assembling the entire structure. Mockito enables the creation of simulated components, mimicking real objects for isolated testing. Simplifying code evaluation, these mock objects ensure controlled testing, facilitating the assessment of code integration without complete assembly

Example: Let’s say you’re writing an app that checks the weather. Instead of actually connecting to a live weather service every time you test your app, you can use Mockito to create a fake weather service that provides pre-defined responses. This way, you can test how your app handles different weather scenarios quickly and easily.

Why Use Mockito?

Often, our classes rely on other classes and their methods. When we unit tests these classes, we aim to keep our tests independent of these dependencies. To achieve this, we use Mockito to create mock versions of the dependency classes, allowing us to focus on testing the main class. This level of isolation isn’t possible with JUnit alone.

Steps for Unit Testing Using Mockito

(Write an example of computations like addition, subtraction, etc to understand the Mockito framework)

Let’s explore a simple example of computations, such as addition and subtraction, to understand how to use the Mockito framework.

### Creating the Computation Classes

We’ll start by creating a file named `ComputationActivity.kt` to display all computations. For managing these operations, we’ll create an `Operations` class in `Operations.kt`. This `Operations` object will be passed as a parameter to the `ComputationActivity` class in its primary constructor.

Copy Code

#### ComputationActivity.kt

```kotlin

class ComputationActivity(private val operators: Operations) {

    fun getAddition(x: Int, y: Int): Int = operators.add(x, y)

    fun getSubtraction(x: Int, y: Int): Int = operators.subtract(x, y)

    fun getMultiplication(x: Int, y: Int): Int = operators.multiply(x, y)

    fun getDivision(x: Int, y: Int): Int = operators.divide(x, y)

}

```

Copy Code

#### Operations.kt

```kotlin

object Operations {

    fun add(x: Int, y: Int): Int = x + y

    fun subtract(x: Int, y: Int): Int = x - y

    fun multiply(x: Int, y: Int): Int = x * y

    fun divide(x: Int, y: Int): Int = x / y

}

```

### Adding Mockito Dependencies

To use Mockito in your project, include the following dependencies in your `build.gradle` file:

Copy Code

```groovy

testImplementation 'junit:junit:4.13.2'

testImplementation 'org.mockito:mockito-core:2.25.0'

testImplementation 'org.mockito:mockito-inline:2.13.0'

```

### Folder Structure for Tests

Place your test files in the `module-name/src/test` directory. This is where local unit tests are typically stored.

### Writing the Tests

Now, let’s add some test functions to our `ComputationTest.kt` file.

1. **MockitoJUnitRunner**: Use the `@RunWith` annotation with `MockitoJUnitRunner::class` to run the tests.

2. **@Mock**: Use the `@Mock` annotation to create mock objects. We will mock the `Operations` class because `ComputationActivity` depends on it.

3. **@Before**: Methods annotated with `@Before` run before each test to set up the test environment.

4. **@Test**: Use this annotation to define test functions.

Copy Code

#### ComputationTest.kt

```kotlin

@RunWith(MockitoJUnitRunner::class)

class ComputationTest {

    @Mock

    lateinit var operators: Operations

    lateinit var computationActivity: ComputationActivity

    @Before

    fun setUp() {

        computationActivity = ComputationActivity(operators)

    }

    @Test

    fun givenValidInput_getAddition_shouldCallAddOperator() {

        val x = 5

        val y = 10

        computationActivity.getAddition(x, y)

        verify(operators).add(x, y)

    }

}

```

The `verify` method checks whether a specific method of a mock object has been called.

Copy Code

### Additional Annotations

- **@After**: Executes after each test case completes.

- **@BeforeClass**: Runs once before all tests to set up resources that are expensive to initialize.

- **@AfterClass**: Runs once after all tests to clean up resources.

### Testing Final Classes

Mockito cannot directly test final or static classes, and Kotlin classes are final by default. To test these classes, you need the `mockito-inline` dependency. 

Mockito 2.25.0 introduced support for developers using `mockito-inline`, which is crucial for testing Kotlin classes. This concludes our tutorial on unit testing using Mockito in Android. Now, you can run the tests to ensure everything works correctly.

Running the Tests

To run all tests, right-click on the `ComputationTest.kt` file and select `Run`.

To run a specific test function, right-click on the desired function and select `Run`.

Conclusion

Mockito is a popular framework used by Android mobile developers to write unit tests, including testing final classes in Kotlin. This overview covered how to use Mockito for unit testing in Android applications. If you have any questions or suggestions, feel free to reach out to us—we’re here to help!

FAQ’S