Mockito doCallRealMethod Method

The doCallRealMethod method in Mockito is used to call the actual implementation of a method on a mock object. This can be useful when you want to test the real behavior of a method while still using a mock object for other methods. This method is typically used in combination with the when method to specify which method calls should use the real implementation.

Table of Contents

1. Introduction
2. doCallRealMethod 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 doCallRealMethod method allows you to call the real implementation of a method on a mock object. This is useful when you want to test the actual behavior of a method while using mocks for other parts of the object.

doCallRealMethod Method Syntax

Calling the Real Method Implementation

static Stubber doCallRealMethod()

Specifies that the real method implementation should be called when the method is invoked on the mock object.

Returns:

• A Stubber object that allows further stubbing configurations.

Examples

Basic Usage

Call the real method implementation on a mock object.

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.doCallRealMethod;
import static org.mockito.Mockito.when;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;

public class BasicDoCallRealMethodTest {
    @Test
    void testDoCallRealMethod() {
        UserService mockUserService = mock(UserService.class);
        
        // Configure the mock to call the real method
        doCallRealMethod().when(mockUserService).getUserDetails("123");
        
        // Call the method
        String details = mockUserService.getUserDetails("123");
        
        // Verify the real method was called
        assertEquals("Real user details for 123", details);
    }
}

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

Combining with Other Stubbing

Combine doCallRealMethod with other stubbing methods for more complex behaviors.

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.doCallRealMethod;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.when;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.Test;

public class CombinedStubbingTest {
    @Test
    void testDoCallRealMethodAndDoReturn() {
        UserService mockUserService = mock(UserService.class);

        // Configure the mock to call the real method
        doCallRealMethod().when(mockUserService).getUserDetails("123");
        
        // Configure the mock to return a specific value for another method
        doReturn("Mock user details for 456").when(mockUserService).getUserDetails("456");

        // Call the methods and verify the behavior
        assertEquals("Real user details for 123", mockUserService.getUserDetails("123"));
        assertEquals("Mock user details for 456", mockUserService.getUserDetails("456"));
    }
}

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

Real-World Use Case

Testing a Service Method with Partial Mocks

In a real-world scenario, you might have a service class where you want to test the real implementation of some methods while using mocks for others.

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.doCallRealMethod;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

interface NotificationService {
    void sendNotification(String message);
}

class UserService {
    private final NotificationService notificationService;

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

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

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

public class UserServiceTest {
    @Test
    void testDeleteUserWithRealMethodCall() {
        NotificationService mockNotificationService = mock(NotificationService.class);
        UserService userService = new UserService(mockNotificationService);
        
        // Configure the mock to do nothing for the sendNotification method
        doNothing().when(mockNotificationService).sendNotification("User 123 deleted");

        // Configure the mock to call the real method for getUserDetails
        doCallRealMethod().when(userService).getUserDetails("123");
        
        // Call the deleteUser method
        userService.deleteUser("123");

        // Verify that the sendNotification method was called
        verify(mockNotificationService).sendNotification("User 123 deleted");

        // Call the getUserDetails method and verify the real method was called
        assertEquals("Real user details for 123", userService.getUserDetails("123"));
    }
}

In this example, the UserServiceTest class uses Mockito’s doCallRealMethod method to call the real implementation of the getUserDetails method while using a mock for the NotificationService. The test verifies that the real method is called correctly and the notification method is called as expected.

Conclusion

The doCallRealMethod method in Mockito is used for testing the real behavior of methods on mock objects. By using doCallRealMethod, you can specify that the actual implementation of a method should be called, allowing you to test the real behavior while still using mocks for other parts of the object. This helps ensure that your tests are comprehensive and accurately reflect the behavior of your code.