Mockito BDDMockito thenDoNothing Method

The thenDoNothing method in the BDDMockito class is part of the Behavior-Driven Development (BDD) style of writing tests using Mockito. It is used to specify that a method on a mock object should do nothing when called. This method is particularly useful for methods that have a void return type and where you want to ensure that the method call does not perform any action or change state.

Table of Contents

1. Introduction
2. thenDoNothing Method Syntax
3. Examples
   • Basic Usage
   • Using thenDoNothing with Multiple Calls
4. Real-World Use Case
5. Conclusion

Introduction

Behavior-Driven Development (BDD) is a software development approach that emphasizes collaboration between developers, QA, and non-technical or business participants in a software project. Mockito’s BDDMockito class provides methods that support the BDD style of writing tests. The thenDoNothing method is used to specify that a method call on a mock object should do nothing, making tests more readable and aligning with the BDD approach.

thenDoNothing Method Syntax

Specifying No Action for a Method Call

import org.mockito.BDDMockito;

static BDDMockito.BDDStubber willDoNothing()

Specifies that the method should do nothing when called.

Returns:

• A BDDStubber object that allows further stubbing.

Examples

Basic Usage

Use thenDoNothing to specify that a void method call on a mock object should do nothing.

import static org.mockito.BDDMockito.*;
import org.junit.jupiter.api.Test;

public class BasicThenDoNothingTest {
    @Test
    void testThenDoNothing() {
        UserService mockUserService = mock(UserService.class);

        // Set up the method to do nothing
        willDoNothing().given(mockUserService).deleteUser("user123");

        // Call the method
        mockUserService.deleteUser("user123");

        // Verify the method call
        then(mockUserService).should().deleteUser("user123");
    }
}

class UserService {
    public void deleteUser(String userId) {
        // Actual deletion logic
    }
}

Using thenDoNothing with Multiple Calls

Use thenDoNothing to specify that multiple void method calls on a mock object should do nothing.

import static org.mockito.BDDMockito.*;
import org.junit.jupiter.api.Test;

public class MultipleThenDoNothingTest {
    @Test
    void testThenDoNothingWithMultipleCalls() {
        UserService mockUserService = mock(UserService.class);

        // Set up the methods to do nothing
        willDoNothing().given(mockUserService).deleteUser("user123");
        willDoNothing().given(mockUserService).deleteUser("user456");

        // Call the methods
        mockUserService.deleteUser("user123");
        mockUserService.deleteUser("user456");

        // Verify the method calls
        then(mockUserService).should().deleteUser("user123");
        then(mockUserService).should().deleteUser("user456");
    }
}

class UserService {
    public void deleteUser(String userId) {
        // Actual deletion logic
    }
}

Real-World Use Case

Simplifying Tests for Services with Void Methods

In a real-world scenario, you might need to test services with methods that have a void return type. Using thenDoNothing can simplify these tests by allowing you to specify that the method calls should do nothing, making your tests more readable and intuitive.

import static org.mockito.BDDMockito.*;
import org.junit.jupiter.api.Test;

interface EmailService {
    void sendEmail(String recipient, String subject, String body);
}

class UserService {
    private final EmailService emailService;

    public UserService(EmailService emailService) {
        this.emailService = emailService;
    }

    public void notifyUser(String userId, String message) {
        emailService.sendEmail(userId, "Notification", message);
    }
}

public class UserServiceTest {
    @Test
    void testNotifyUser() {
        EmailService mockEmailService = mock(EmailService.class);
        UserService userService = new UserService(mockEmailService);

        // Set up the method to do nothing
        willDoNothing().given(mockEmailService).sendEmail("user123", "Notification", "Your account has been updated.");

        // Call the method
        userService.notifyUser("user123", "Your account has been updated.");

        // Verify the interaction
        then(mockEmailService).should().sendEmail("user123", "Notification", "Your account has been updated.");
    }
}

In this example, the UserServiceTest class uses Mockito’s BDDMockito.thenDoNothing method to set up the sendEmail method to do nothing when called. This simplifies the test by allowing you to specify that the method call should do nothing and verify the interaction in a readable and intuitive way.

Conclusion

The BDDMockito.thenDoNothing method in Mockito is used for specifying that void methods on mock objects should do nothing when called in a BDD style. By using thenDoNothing, you can make your tests more readable and align them with the BDD approach, focusing on the behavior of the application rather than the implementation details. This helps ensure that your tests are clear, comprehensive, and easy to understand.