Mockito BDDMockito times Method

The times method in the BDDMockito class is part of the Behavior-Driven Development (BDD) style of writing tests using Mockito. It is used to verify that a method on a mock object was called a specific number of times.

Table of Contents

1. Introduction
2. times Method Syntax
3. Examples
   • Basic Usage
   • Using times with Other Verification Methods
4. Real-World Use Case
5. Conclusion

Introduction

Mockito’s BDDMockito class provides methods that support the BDD style of writing tests. The times method is used to verify that a method on a mock object was called a specific number of times, making tests more readable and intuitive. This method is particularly useful for making tests more readable and aligning with the BDD style, which focuses on describing the behavior of the application in a clear and human-readable format.

times Method Syntax

Verifying Method Call Times

import org.mockito.BDDMockito;

static VerificationMode times(int wantedNumberOfInvocations)

Allows verifying that a method was called a specific number of times.

Parameters:

• wantedNumberOfInvocations: The number of times the method should have been called.

Returns:

• A VerificationMode object that allows further verification.

Examples

Basic Usage

Use times to verify that a method was called a specific number of times on a mock object.

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

public class BasicTimesTest {
    @Test
    void testTimes() {
        UserService mockUserService = mock(UserService.class);

        // Call the method multiple times
        mockUserService.getUserDetails("user123");
        mockUserService.getUserDetails("user123");

        // Verify the method call with times
        then(mockUserService).should(times(2)).getUserDetails("user123");
    }
}

class UserService {
    public String getUserDetails(String userId) {
        return "Real user details for " + userId;
    }
}

Using times with Other Verification Methods

Use times in combination with other verification methods to check specific interactions with a mock object.

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

public class TimesWithVerificationMethodsTest {
    @Test
    void testTimesWithVerificationMethods() {
        NotificationService mockNotificationService = mock(NotificationService.class);

        // Call the method multiple times
        mockNotificationService.sendNotification("user123", "Message 1");
        mockNotificationService.sendNotification("user123", "Message 2");

        // Verify the method call with times and argument matchers
        then(mockNotificationService).should(times(2)).sendNotification(eq("user123"), anyString());
    }
}

interface NotificationService {
    void sendNotification(String recipient, String message);
}

Real-World Use Case

Verifying Method Call Counts in Services

In a real-world scenario, you might need to verify that a service method is called a specific number of times to ensure that certain operations are performed the expected number of times. Using times can simplify these tests by allowing you to specify the expected number of calls, 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);
        emailService.sendEmail(userId, "Follow-up", message);
    }
}

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

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

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

In this example, the UserServiceTest class uses Mockito’s BDDMockito.times method to verify that the sendEmail method was called twice on the EmailService mock. This simplifies the test by allowing you to specify the expected number of calls and verify the interaction in a readable and intuitive way.

Conclusion

The BDDMockito.times method in Mockito is used for verifying that methods on mock objects were called a specific number of times in a BDD style. By using times, 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.