Mockito BDDMockito spy Method

The spy method in the BDDMockito class is part of the Behavior-Driven Development (BDD) style of writing tests using Mockito. It is used to create spy objects for classes and interfaces, enabling partial mocking.

Table of Contents

1. Introduction
2. spy Method Syntax
3. Examples
   • Basic Usage
   • Spying on Real Objects
   • Spying with Custom Settings
4. Real-World Use Case
5. Conclusion

Introduction

Mockito’s BDDMockito class provides methods that support the BDD style of writing tests. The spy method is used to create spy objects, allowing you to partially mock a real object by stubbing specific methods while keeping the rest of the object’s behavior intact.

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.

spy Method Syntax

Creating a Spy Object

import org.mockito.BDDMockito;

static <T> T spy(Class<T> classToSpy)

Creates a spy object of the given class or interface.

Parameters:

• classToSpy: The class or interface to be spied on.

Returns:

• A spy object of the specified class or interface.

Creating a Spy from an Existing Object

import org.mockito.BDDMockito;

static <T> T spy(T object)

Creates a spy object from an existing real object.

Parameters:

• object: The real object to be spied on.

Returns:

• A spy object that wraps the given real object.

Examples

Basic Usage

Use spy to create a basic spy object for a class or interface.

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

public class BasicSpyTest {
    @Test
    void testSpy() {
        UserService userService = spy(new UserService());

        // Set up the method to return a mocked value
        willReturn("Mock user details").given(userService).getUserDetails("user123");

        // Call the method
        String result = userService.getUserDetails("user123");

        // Verify the result
        assertEquals("Mock user details", result);

        // Call the real method
        String realResult = userService.getUserDetails("user456");

        // Verify the real method result
        assertEquals("Real user details for user456", realResult);
    }
}

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

Spying on Real Objects

Use spy to create a spy object from an existing real object.

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

public class SpyRealObjectTest {
    @Test
    void testSpyRealObject() {
        UserService realUserService = new UserService();
        UserService spyUserService = spy(realUserService);

        // Set up the method to return a mocked value
        willReturn("Mock user details").given(spyUserService).getUserDetails("user123");

        // Call the method
        String result = spyUserService.getUserDetails("user123");

        // Verify the result
        assertEquals("Mock user details", result);

        // Call the real method
        String realResult = spyUserService.getUserDetails("user456");

        // Verify the real method result
        assertEquals("Real user details for user456", realResult);
    }
}

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

Spying with Custom Settings

Use spy to create a spy object with custom settings.

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

public class SpyWithCustomSettingsTest {
    @Test
    void testSpyWithCustomSettings() {
        UserService userService = spy(UserService.class, withSettings().name("customUserServiceSpy"));

        // Set up the method to return a mocked value
        willReturn("Mock user details").given(userService).getUserDetails("user123");

        // Call the method
        String result = userService.getUserDetails("user123");

        // Verify the result
        assertEquals("Mock user details", result);

        // Call the real method
        String realResult = userService.getUserDetails("user456");

        // Verify the real method result
        assertEquals("Real user details for user456", realResult);
    }
}

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

Real-World Use Case

Simplifying Tests for Services with Partial Mocking

In a real-world scenario, you might need to test services that have complex behaviors, where you want to mock specific methods while keeping the rest of the object’s behavior intact. Using spy can simplify these tests by allowing you to partially mock the object, making your tests more readable and intuitive.

import static org.mockito.BDDMockito.*;
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 String notifyUser(String userId, String message) {
        emailService.sendEmail(userId, "Notification", message);
        return "Notification sent to " + userId;
    }

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

public class UserServiceTest {
    @Test
    void testNotifyUserWithPartialMocking() {
        EmailService mockEmailService = mock(EmailService.class);
        UserService realUserService = new UserService(mockEmailService);
        UserService spyUserService = spy(realUserService);

        // Set up the method to do nothing
        willDoNothing().given(mockEmailService).sendEmail(anyString(), anyString(), anyString());

        // Call the method
        String result = spyUserService.notifyUser("user123", "Your account has been updated.");

        // Verify the result and interaction
        assertEquals("Notification sent to user123", result);
        then(mockEmailService).should().sendEmail("user123", "Notification", "Your account has been updated.");

        // Call the real method
        String realResult = spyUserService.getUserDetails("user123");

        // Verify the real method result
        assertEquals("Real user details for user123", realResult);
    }
}

In this example, the UserServiceTest class uses Mockito’s BDDMockito.spy method to create a spy object for the UserService class. This simplifies the test by allowing you to partially mock the object and verify the interaction in a readable and intuitive way.

Conclusion

The BDDMockito.spy method in Mockito is used for creating spy objects for classes and interfaces in a BDD style. By using spy, 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.