Mockito doNothing Method

The doNothing method in Mockito is used to configure void methods to do nothing when they are called. This is useful when you want to ignore calls to certain void methods during your tests without affecting the behavior of other methods. The doNothing method is typically used in combination with the when method to specify the behavior of void methods.

Table of Contents

1. Introduction
2. doNothing Method Syntax
3. Examples
   • Basic Usage
   • Combining with Other Stubbing
4. Real-World Use Case
5. Conclusion

Introduction

Mockito is a popular library in Java for creating and managing mock objects. The doNothing method allows you to configure void methods on your mock objects to do nothing when they are called. This can be helpful when you want to focus on testing specific behaviors without being interrupted by void method calls.

doNothing Method Syntax

Setting Void Methods to Do Nothing

static Stubber doNothing()

Sets the void method to do nothing when it is called.

Examples

Basic Usage

Configure a void method to do nothing when it is called.

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.verify;
import org.junit.jupiter.api.Test;

public class BasicDoNothingTest {
    @Test
    void testDoNothing() {
        UserService mockUserService = mock(UserService.class);
        // Configure the void method to do nothing
        doNothing().when(mockUserService).deleteUser("123");
        // Call the method
        mockUserService.deleteUser("123");
        // Verify that the method was called
        verify(mockUserService).deleteUser("123");
    }
}

class UserService {
    public void deleteUser(String userId) {
        // Method implementation
    }
}

Combining with Other Stubbing

Combine doNothing with other stubbing methods for more complex behaviors.

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.verify;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertThrows;

public class CombinedStubbingTest {
    @Test
    void testDoNothingAndDoThrow() {
        UserService mockUserService = mock(UserService.class);
        // Configure the void method to do nothing
        doNothing().when(mockUserService).deleteUser("123");
        // Configure the void method to throw an exception on the next call
        doThrow(new RuntimeException("User not found")).when(mockUserService).deleteUser("456");

        // Call the method and verify it does nothing
        mockUserService.deleteUser("123");
        verify(mockUserService).deleteUser("123");

        // Call the method and verify it throws an exception
        assertThrows(RuntimeException.class, () -> mockUserService.deleteUser("456"));
    }
}

class UserService {
    public void deleteUser(String userId) {
        // Method implementation
    }
}

Real-World Use Case

Testing a Service Method that Calls a Void Method

In a real-world scenario, you might have a service class that calls a void method on a dependency. Using doNothing, you can configure the void method to do nothing during your test.

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.verify;
import org.junit.jupiter.api.Test;

interface NotificationService {
    void sendNotification(String message);
}

class UserService {
    private final NotificationService notificationService;

    public UserService(NotificationService notificationService) {
        this.notificationService = notificationService;
    }

    public void deleteUser(String userId) {
        // Perform user deletion logic
        notificationService.sendNotification("User " + userId + " deleted");
    }
}

public class UserServiceTest {
    @Test
    void testDeleteUser() {
        NotificationService mockNotificationService = mock(NotificationService.class);
        UserService userService = new UserService(mockNotificationService);
        
        // Configure the sendNotification method to do nothing
        doNothing().when(mockNotificationService).sendNotification("User 123 deleted");
        
        // Call the deleteUser method
        userService.deleteUser("123");
        
        // Verify that the sendNotification method was called
        verify(mockNotificationService).sendNotification("User 123 deleted");
    }
}

In this example, the UserServiceTest class uses Mockito’s doNothing method to configure the sendNotification method of the NotificationService interface to do nothing when called. The test verifies that the sendNotification method is called during the execution of the deleteUser method in the UserService class.

Conclusion

The doNothing method in Mockito is used for configuring void methods to do nothing when called. This allows you to focus on testing specific behaviors without being interrupted by void method calls. By using doNothing in combination with other stubbing methods, you can create flexible and comprehensive tests for your Java applications.