Mockito mockConstruction Method

The mockConstruction method in the Mockito framework is used to create a thread-local mock controller for all constructions of a given class. This allows you to mock the behavior of newly constructed objects of a specified class, providing fine-grained control over the instantiation process.

Table of Contents

1. Introduction
2. mockConstruction Method Syntax
3. Examples
   • Basic Usage
   • Using Custom Mock Settings
   • Using a Mock Initializer
   • Combining Mock Settings and Initializer
4. Real-World Use Case
5. Conclusion

Introduction

Mockito is a popular library in Java for creating and managing mock objects. The mockConstruction method, which belongs to the Mockito class, allows you to mock the construction of objects. This can be useful for controlling the behavior of newly instantiated objects within your tests, ensuring that they conform to your testing requirements.

mockConstruction Method Syntax

Creating a Basic Mock Controller for All Constructions

static <T> MockedConstruction<T> mockConstruction(Class<T> classToMock)

Creates a thread-local mock controller for all constructions of the given class.

Using a Custom Mock Settings Factory

static <T> MockedConstruction<T> mockConstruction(Class<T> classToMock, Function<MockedConstruction.Context, MockSettings> mockSettingsFactory)

Creates a thread-local mock controller for all constructions of the given class with custom mock settings.

Using a Mock Initializer

static <T> MockedConstruction<T> mockConstruction(Class<T> classToMock, MockedConstruction.MockInitializer<T> mockInitializer)

Creates a thread-local mock controller for all constructions of the given class with a mock initializer.

Combining Mock Settings and Initializer

static <T> MockedConstruction<T> mockConstruction(Class<T> classToMock, Function<MockedConstruction.Context, MockSettings> mockSettingsFactory, MockedConstruction.MockInitializer<T> mockInitializer)

Creates a thread-local mock controller for all constructions of the given class with custom mock settings and a mock initializer.

Using Mock Settings

static <T> MockedConstruction<T> mockConstruction(Class<T> classToMock, MockSettings mockSettings)

Creates a thread-local mock controller for all constructions of the given class with specific mock settings.

Combining Mock Settings and Initializer with Mock Settings Object

static <T> MockedConstruction<T> mockConstruction(Class<T> classToMock, MockSettings mockSettings, MockedConstruction.MockInitializer<T> mockInitializer)

Creates a thread-local mock controller for all constructions of the given class with specific mock settings and a mock initializer.

Using Default and Additional Answers

static <T> MockedConstruction<T> mockConstructionWithAnswer(Class<T> classToMock, Answer defaultAnswer, Answer... additionalAnswers)

Creates a thread-local mock controller for all constructions of the given class with specific answers.

Examples

Basic Usage

Mock the construction of a simple class.

import static org.mockito.Mockito.mockConstruction;
import static org.mockito.Mockito.when;
import org.mockito.MockedConstruction;
import org.junit.jupiter.api.Test;

public class BasicMockConstructionTest {
    @Test
    void testMockConstruction() {
        try (MockedConstruction<UserService> mocked = mockConstruction(UserService.class)) {
            UserService userService = new UserService();
            when(userService.getUserDetails("123")).thenReturn("Mock user details");

            String details = userService.getUserDetails("123");
            System.out.println(details);  // Outputs: Mock user details
        }
    }
}

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

Using Custom Mock Settings

Mock the construction of a class with custom mock settings.

import static org.mockito.Mockito.mockConstruction;
import static org.mockito.Mockito.withSettings;
import static org.mockito.Mockito.when;
import org.mockito.MockedConstruction;
import org.mockito.MockSettings;
import org.junit.jupiter.api.Test;

public class CustomMockSettingsTest {
    @Test
    void testCustomMockSettings() {
        MockSettings mockSettings = withSettings().defaultAnswer(invocation -> "Default answer");

        try (MockedConstruction<UserService> mocked = mockConstruction(UserService.class, mockSettings)) {
            UserService userService = new UserService();

            String details = userService.getUserDetails("123");
            System.out.println(details);  // Outputs: Default answer
        }
    }
}

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

Using a Mock Initializer

Mock the construction of a class with a mock initializer.

import static org.mockito.Mockito.mockConstruction;
import static org.mockito.Mockito.when;
import org.mockito.MockedConstruction;
import org.junit.jupiter.api.Test;

public class MockInitializerTest {
    @Test
    void testMockInitializer() {
        try (MockedConstruction<UserService> mocked = mockConstruction(UserService.class, (mock, context) -> {
            when(mock.getUserDetails("123")).thenReturn("Initialized mock details");
        })) {
            UserService userService = new UserService();

            String details = userService.getUserDetails("123");
            System.out.println(details);  // Outputs: Initialized mock details
        }
    }
}

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

Combining Mock Settings and Initializer

Mock the construction of a class with custom mock settings and a mock initializer.

import static org.mockito.Mockito.mockConstruction;
import static org.mockito.Mockito.withSettings;
import static org.mockito.Mockito.when;
import org.mockito.MockedConstruction;
import org.mockito.MockSettings;
import org.junit.jupiter.api.Test;

public class CombinedMockSettingsInitializerTest {
    @Test
    void testCombinedMockSettingsInitializer() {
        MockSettings mockSettings = withSettings().defaultAnswer(invocation -> "Default answer");

        try (MockedConstruction<UserService> mocked = mockConstruction(UserService.class, mockSettings, (mock, context) -> {
            when(mock.getUserDetails("123")).thenReturn("Initialized mock details");
        })) {
            UserService userService = new UserService();

            String details = userService.getUserDetails("123");
            System.out.println(details);  // Outputs: Initialized mock details
        }
    }
}

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

Real-World Use Case

Mocking Service Instantiations in a Service-Oriented Architecture

In a real-world scenario, you might want to mock the construction of service classes to control their behavior during testing. This can be especially useful in service-oriented architectures where services are frequently instantiated and used.

import static org.mockito.Mockito.mockConstruction;
import static org.mockito.Mockito.when;
import org.mockito.MockedConstruction;
import org.junit.jupiter.api.Test;

interface PaymentService {
    void processPayment(String orderId);
    String getPaymentStatus(String orderId);
}

class PaymentServiceImpl implements PaymentService {
    public void processPayment(String orderId) {
        // Real implementation
    }

    public String getPaymentStatus(String orderId) {
        return "Processing";
    }
}

class OrderService {
    public void placeOrder(String orderId) {
        PaymentService paymentService = new PaymentServiceImpl();
        paymentService.processPayment(orderId);
        System.out.println(paymentService.getPaymentStatus(orderId));
    }
}

public class OrderServiceTest {
    @Test
    void testOrderServiceWithMockedPaymentService() {
        try (MockedConstruction<PaymentServiceImpl> mocked = mockConstruction(PaymentServiceImpl.class, (mock, context) -> {
            when(mock.getPaymentStatus("123")).thenReturn("Completed");
        })) {
            OrderService orderService = new OrderService();
            orderService.placeOrder("123");
            // Output: Completed
        }
    }
}

In this example, the OrderServiceTest class uses Mockito’s mockConstruction method to mock the construction of the PaymentServiceImpl class. This allows you to control the behavior of the PaymentService instance used in the OrderService class, ensuring that it returns the desired response during testing.

Conclusion

The mockConstruction method in Mockito is used for creating thread-local mock controllers for all constructions of a given class. By using mockConstruction, you can control the behavior of newly instantiated objects within your tests, providing fine-grained control over the instantiation process. This helps ensure that your tests are accurate and comprehensive, allowing you to validate both real and mocked behavior.