The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Using Mockito with JUnit

Next ►
►

In this section, we will explore how to use Mockito, a popular mocking framework, in conjunction with JUnit to create effective unit tests. Mocking is a technique used to isolate the unit of work by replacing dependencies with mock objects that simulate the behavior of real objects.

What is Mockito?

Mockito is a Java-based mocking framework used for unit testing. It allows you to create mock objects and define their behavior, making it easier to test components in isolation.

Key Features of Mockito:

  • Creating Mock Objects: Easily create mock instances of classes.
  • Stubbing Methods: Define the behavior of methods in mock objects.
  • Verifying Interactions: Check if certain methods were called on the mock objects.
  • Argument Capturing: Capture arguments passed to methods for further assertions.

Setting Up Mockito with JUnit

To use Mockito with JUnit, you need to add the Mockito library to your project. If you are using Maven, add the following dependency to your pom.xml file:

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>3.11.2</version>
    <scope>test</scope>
</dependency>

For Gradle, add the following to your build.gradle file:

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

Creating Mock Objects

To create a mock object, use the Mockito.mock() method. Here is an example:

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;

import static org.junit.jupiter.api.Assertions.assertEquals;

public class MockitoExampleTest {

    @Test
    public void testMockObject() {
        // Create a mock object of the List class
        List<String> mockList = Mockito.mock(List.class);

        // Define the behavior of the mock object
        Mockito.when(mockList.size()).thenReturn(5);

        // Use the mock object
        assertEquals(5, mockList.size());
    }
}

Explanation:

  • Creating the Mock: Mockito.mock(List.class) creates a mock object of the List class.
  • Stubbing the Method: Mockito.when(mockList.size()).thenReturn(5) defines that when the size() method is called on the mock object, it should return 5.
  • Using the Mock: The assertEquals(5, mockList.size()) assertion verifies that the size() method returns 5 as defined.

Verifying Interactions

Mockito allows you to verify if certain methods were called on the mock objects. Here is an example:

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;

import java.util.List;

import static org.mockito.Mockito.verify;

public class MockitoVerifyTest {

    @Test
    public void testVerifyInteraction() {
        // Create a mock object of the List class
        List<String> mockList = Mockito.mock(List.class);

        // Use the mock object
        mockList.add("one");
        mockList.clear();

        // Verify interactions
        verify(mockList).add("one");
        verify(mockList).clear();
    }
}

Explanation:

  • Using the Mock: The mockList.add("one") and mockList.clear() methods are called on the mock object.
  • Verifying Interactions: The verify(mockList).add("one") and verify(mockList).clear() methods check if the add("one") and clear() methods were called on the mock object.

Practical Exercise

Exercise:

Create a mock object of a custom class and define its behavior. Verify the interactions with the mock object.

  1. Create a class Calculator with a method add(int a, int b) that returns the sum of two integers.
  2. Create a test class CalculatorTest and use Mockito to create a mock object of the Calculator class.
  3. Stub the add method to return a specific value.
  4. Verify that the add method was called with specific arguments.

Solution:

// Calculator.java
public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

// CalculatorTest.java
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.verify;

public class CalculatorTest {

    @Test
    public void testAddMethod() {
        // Create a mock object of the Calculator class
        Calculator mockCalculator = Mockito.mock(Calculator.class);

        // Define the behavior of the add method
        Mockito.when(mockCalculator.add(2, 3)).thenReturn(5);

        // Use the mock object
        int result = mockCalculator.add(2, 3);

        // Verify the result
        assertEquals(5, result);

        // Verify interactions
        verify(mockCalculator).add(2, 3);
    }
}

Explanation:

  • Creating the Mock: Mockito.mock(Calculator.class) creates a mock object of the Calculator class.
  • Stubbing the Method: Mockito.when(mockCalculator.add(2, 3)).thenReturn(5) defines that when the add(2, 3) method is called on the mock object, it should return 5.
  • Using the Mock: The mockCalculator.add(2, 3) method is called, and the result is verified using assertEquals(5, result).
  • Verifying Interactions: The verify(mockCalculator).add(2, 3) method checks if the add(2, 3) method was called on the mock object.

Conclusion

In this section, we learned how to use Mockito with JUnit to create mock objects, define their behavior, and verify interactions. Mocking is a powerful technique that helps in isolating the unit of work and testing components in isolation. In the next section, we will explore how to create mocks and verify interactions in more detail.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved