Mockito same Method

The same method in the Mockito framework is part of the ArgumentMatchers class. It is used to match an argument that is the same as the given value (i.e., the same instance). This is particularly useful when you need to verify or stub method calls where the argument should be the exact same instance as the provided value.

Table of Contents

1. Introduction
2. same Method Syntax
3. Examples
   • Basic Usage
   • Using same with Different Types
4. Real-World Use Case
5. Conclusion

Introduction

Mockito is a popular library in Java for creating and managing mock objects. The same method, which belongs to the ArgumentMatchers class, allows you to specify that an argument should be the exact same instance as the given value. This can be useful for tests where the identity of the argument matters, not just its value.

same Method Syntax

Matching the Same Instance

import org.mockito.ArgumentMatchers;

static <T> T same(T value)

Matches any argument that is the same instance as the given value.

Parameters:

• value: The value to be matched for instance identity.

Returns:

• An argument of type T that is the same instance as the given value.

Examples

Basic Usage

Use same to match an argument that is the same instance in a mocked method call.

import static org.mockito.Mockito.*;
import org.mockito.ArgumentMatchers;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class BasicSameTest {
    @Test
    void testSame() {
        UserService mockUserService = mock(UserService.class);
        User user = new User("user123");

        // Stub the method to return a specific value
        when(mockUserService.getUserDetails(ArgumentMatchers.same(user))).thenReturn("User details");

        // Call the method with the same instance
        String result = mockUserService.getUserDetails(user);

        // Verify the result
        assertEquals("User details", result);
    }
}

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

class User {
    private final String username;

    public User(String username) {
        this.username = username;
    }

    public String getUsername() {
        return username;
    }
}

Using same with Different Types

Use same to match arguments of different types by their instance identity in mocked method calls.

import static org.mockito.Mockito.*;
import org.mockito.ArgumentMatchers;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class DifferentTypesSameTest {
    @Test
    void testSameWithDifferentTypes() {
        NotificationService mockNotificationService = mock(NotificationService.class);
        String subject = "Notification";
        User user = new User("user123");

        // Stub the method to return specific values
        when(mockNotificationService.sendNotification(ArgumentMatchers.same(subject), ArgumentMatchers.same(user))).thenReturn("Notification sent");

        // Call the method with the same instances
        String result = mockNotificationService.sendNotification(subject, user);

        // Verify the result
        assertEquals("Notification sent", result);
    }
}

interface NotificationService {
    String sendNotification(String subject, User recipient);
}

class User {
    private final String username;

    public User(String username) {
        this.username = username;
    }

    public String getUsername() {
        return username;
    }
}

Real-World Use Case

Simplifying Tests for Services with Specific Object Instance Requirements

In a real-world scenario, you might need to test services with methods that require specific object instances as arguments. Using same can simplify these tests by allowing you to focus on the behavior you are testing rather than the specific content of the arguments, as long as they are the same instance.

import static org.mockito.Mockito.*;
import org.mockito.ArgumentMatchers;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

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(User user, String message) {
        // User notification logic
        emailService.sendEmail(user.getUsername(), "Notification", message);
    }
}

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

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

        // Verify the interaction
        verify(mockEmailService).sendEmail(ArgumentMatchers.same("user123"), ArgumentMatchers.eq("Notification"), ArgumentMatchers.same("Your account has been updated."));
    }
}

In this example, the UserServiceTest class uses Mockito’s same method to match the exact same instance of the arguments for the sendEmail method. This simplifies the test by allowing you to verify the interaction based on the instance identity of the arguments, without worrying about their exact values.

Conclusion

The same method in Mockito is used for matching any argument that is the same instance as a given value in mocked method calls. By using same, you can simplify your tests and focus on the behavior you are testing, rather than the instance identity of the arguments. This helps ensure that your tests are flexible, comprehensive, and easy to maintain.