Mockito Framework Tutorial

Mockito is a powerful Java framework used for unit testing by creating mock objects. It helps developers isolate components of a system, making testing easier, faster, and more reliable. In this tutorial, we'll cover the basics of using Mockito, including creating mocks, stubbing methods, verifying behavior, and more.

Prerequisites

• Basic knowledge of Java.

• Familiarity with unit testing frameworks like JUnit.

• Maven or Gradle build tools.

Setting Up Mockito

Add Mockito to your project by including the dependency in your build file:

Maven

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

Gradle

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

Key Concepts in Mockito

1. Mock Objects:

   • Mocks are fake objects that mimic the behavior of real objects.

2. Spies:

   • Spies are partial mocks that wrap real objects, allowing you to stub specific methods while keeping the real behavior of others.

3. Stubbing:

   • Stubbing allows you to define what a mocked method should return when called with specific arguments.

4. Verification:

   • Verify that a method was called (or not called) on a mock object with specific arguments.

Basic Mockito Examples

1. Creating a Mock Object

import org.mockito.Mockito;
import static org.mockito.Mockito.*;

class Service {
    public String fetchData() {
        return "Real Data";
    }
}

public class MockExample {
    public static void main(String[] args) {
        // Create a mock object
        Service serviceMock = mock(Service.class);

        // Stub a method
        when(serviceMock.fetchData()).thenReturn("Mock Data");

        // Call the method
        String result = serviceMock.fetchData();

        // Print the result
        System.out.println(result); // Output: Mock Data
    }
}

2. Verifying Behavior

import static org.mockito.Mockito.*;

public class VerifyExample {
    public static void main(String[] args) {
        Service serviceMock = mock(Service.class);

        // Call the mock method
        serviceMock.fetchData();

        // Verify the method was called
        verify(serviceMock).fetchData();

        // Verify no other interactions occurred
        verifyNoMoreInteractions(serviceMock);
    }
}

3. Stubbing with Argument Matchers

import static org.mockito.Mockito.*;

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

public class ArgumentMatcherExample {
    public static void main(String[] args) {
        Calculator calculatorMock = mock(Calculator.class);

        // Stub with argument matchers
        when(calculatorMock.add(anyInt(), eq(10))).thenReturn(20);

        // Call the method
        int result = calculatorMock.add(5, 10);

        // Print the result
        System.out.println(result); // Output: 20

        // Verify interaction
        verify(calculatorMock).add(anyInt(), eq(10));
    }
}

Advanced Features

1. Spying on Real Objects

import static org.mockito.Mockito.*;

class RealService {
    public String getData() {
        return "Real Data";
    }
}

public class SpyExample {
    public static void main(String[] args) {
        RealService realService = new RealService();

        // Create a spy
        RealService spyService = spy(realService);

        // Stub a method
        when(spyService.getData()).thenReturn("Stubbed Data");

        // Call the method
        String result = spyService.getData();

        // Print the result
        System.out.println(result); // Output: Stubbed Data

        // Verify interaction
        verify(spyService).getData();
    }
}

2. Capturing Arguments

import org.mockito.ArgumentCaptor;
import static org.mockito.Mockito.*;

public class ArgumentCaptorExample {
    public static void main(String[] args) {
        Service serviceMock = mock(Service.class);

        // Call the mock method
        serviceMock.fetchData();

        // Capture arguments
        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
        verify(serviceMock).fetchData();

        // Print captured argument
        System.out.println("Method called with captured argument: " + captor.getValue());
    }
}

Annotations in Mockito

Mockito provides annotations to make tests cleaner and easier to read.

Common Annotations

• @Mock: Creates a mock object.

• @Spy: Creates a spy object.

• @InjectMocks: Injects mock objects into the class under test.

• @Captor: Captures arguments passed to methods.

Example Using Annotations

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

class MyService {
    private Dependency dependency;

    public MyService(Dependency dependency) {
        this.dependency = dependency;
    }

    public String process() {
        return dependency.getData();
    }
}

class Dependency {
    public String getData() {
        return "Real Data";
    }
}

public class AnnotationExample {

    @Mock
    private Dependency dependencyMock;

    @InjectMocks
    private MyService myService;

    @Test
    public void testProcess() {
        MockitoAnnotations.openMocks(this);

        // Stub the dependency method
        when(dependencyMock.getData()).thenReturn("Mock Data");

        // Call the method
        String result = myService.process();

        // Assert the result
        System.out.println(result); // Output: Mock Data
    }
}

Best Practices

• Mock only what is necessary; avoid over-mocking.

• Use @InjectMocks to reduce boilerplate.

• Avoid mocking value objects or data models.

• Write tests that are easy to understand and maintain.

• Use verifyNoMoreInteractions() to ensure no unintended interactions.

Conclusion

Mockito is an invaluable tool for unit testing in Java. It simplifies the testing process by providing powerful features for mocking, stubbing, and verifying behavior. With practice, you can use Mockito to write clean, reliable, and maintainable tests for your Java applications.