Mockito Framework Tutorial : A Comprehensive Guide for Java Developers

Mockito is a powerful, open-source testing framework for Java that enables developers to create mock objects for unit testing. It simplifies the process of writing clean, readable, and maintainable tests. This mockito framework tutorial will cover all aspects of Mockito, providing relevant examples to help you master this essential tool.

Mockito Framework Tutorial

What is Mockito?

Mockito is a popular mocking framework for Java applications. It allows you to create mock objects for your classes, making it easier to isolate and test individual components of your application. Mockito helps in verifying the behavior of your code by providing various functionalities like stubbing, verification, and argument capture.

Why Use Mockito?

1. Isolation: Mockito helps in isolating the class under test by mocking its dependencies.
2. Simplicity: It simplifies the process of writing unit tests.
3. Readability: Tests written with Mockito are clean and easy to understand.
4. Integration: Mockito integrates seamlessly with other testing frameworks like JUnit.

Getting Started with Mockito

To start using Mockito, you need to add the Mockito dependency to your project. For Maven, add the following dependency:

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

For Gradle, add the following:

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

Creating Mock Objects

Creating a mock object in Mockito is straightforward. You can use the @Mock annotation or the Mockito.mock() method. Here’s an example:

import static org.mockito.Mockito.*;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

class MyServiceTest {

    @Mock
    private MyDependency myDependency;

    @Test
    void testMyService() {
        MockitoAnnotations.openMocks(this);
        MyService myService = new MyService(myDependency);
        when(myDependency.someMethod()).thenReturn("Mocked Response");

        String response = myService.callDependency();

        assertEquals("Mocked Response", response);
    }
}

In this example, myDependency is a mock object, and we stub the someMethod() to return “Mocked Response”.

Stubbing Methods

Stubbing is the process of instructing a mock object on what to do when its methods are called. Here’s how you can stub methods using Mockito:

when(mockObject.methodToStub()).thenReturn(desiredValue);

For example:

when(myDependency.someMethod()).thenReturn("Mocked Response");

Verifying Interactions

Mockito allows you to verify the interactions between the class under test and its dependencies. You can check if a method was called, how many times it was called, and with what arguments:

verify(mockObject).methodToVerify();

For example:

verify(myDependency).someMethod();

You can also verify the number of times a method was called:

verify(myDependency, times(1)).someMethod();

Using Mockito doNothing()

In some cases, you may want to stub void methods that don’t return anything. Mockito’s doNothing() method is useful in such scenarios:

doNothing().when(mockObject).methodToStub();

For example:

doNothing().when(myDependency).voidMethod();

Argument Captors

Argument captors are used to capture the arguments passed to a method when it is called. This is useful when you need to assert something about the arguments. Here’s how to use an argument captor:

ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
verify(mockObject).methodToVerify(captor.capture());
assertEquals("Expected Argument", captor.getValue());

Advanced Mockito Features

1. Spying: Spies allow you to create partial mocks. You can use a real instance of the class but still stub certain methods:

   MyService realService = new MyService();
   MyService spyService = spy(realService);
   when(spyService.someMethod()).thenReturn("Mocked Response");

2. Mocking Static Methods: Starting from Mockito 3.4.0, you can mock static methods using the mockStatic method:

   try (MockedStatic<SomeClass> mockedStatic = mockStatic(SomeClass.class)) {
       mockedStatic.when(SomeClass::staticMethod).thenReturn("Mocked Response");
       assertEquals("Mocked Response", SomeClass.staticMethod());
   }

3. Mocking Final Classes and Methods: Mockito can mock final classes and methods using the mock method:

   final class FinalClass {
       final String finalMethod() {
           return "Original Response";
       }
   }

   FinalClass mockFinalClass = mock(FinalClass.class);
   when(mockFinalClass.finalMethod()).thenReturn("Mocked Response");

Best Practices for Using Mockito

1. Keep Tests Simple: Write simple and focused tests that are easy to read and maintain.
2. Use Annotations: Use @Mock, @InjectMocks, and @Captor annotations for cleaner code.
3. Verify Behavior: Always verify the behavior of your mocks to ensure your code interacts with dependencies as expected.
4. Avoid Over-Mocking: Only mock what is necessary. Over-mocking can make tests brittle and hard to understand.

Conclusion

The Mockito framework is a versatile and essential tool for Java developers, enabling the creation of robust unit tests by mocking dependencies. By mastering the features covered in the Mockito framework tutorial, including creating mocks, stubbing methods, verifying interactions, capturing arguments, and utilizing advanced features like spying and mocking static methods, you can write clean, maintainable, and reliable tests for your Java applications. Integrating Mockito with other testing frameworks like JUnit further enhances its capabilities, making it a cornerstone of effective Java testing practices.

If you are preparing for Java interview you can checkout here.