Mockito inOrder Method

The inOrder method in Mockito is used to create an InOrder object that allows you to verify the order of interactions on one or more mock objects. This is useful when the sequence of method calls is important for your test, and you need to ensure that methods are called in a specific order.

Table of Contents

1. Introduction
2. inOrder Method Syntax
3. Examples
   • Basic Usage
   • Verifying Multiple Mocks
4. Real-World Use Case
5. Conclusion

Introduction

Mockito is a popular library in Java for creating and managing mock objects. The inOrder method allows you to verify that interactions with mock objects happen in a specific sequence. This can be essential for tests where the order of method calls is critical to the logic being tested.

inOrder Method Syntax

Creating an InOrder Object

static InOrder inOrder(Object... mocks)

Creates an InOrder object that allows verifying the order of interactions on the given mock objects.

Parameters:

• mocks: The mock objects to be verified in order.

Returns:

• An InOrder object that can be used to verify the sequence of interactions.

Examples

Basic Usage

Verify the order of interactions on a single mock object.

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.verify;
import org.mockito.InOrder;
import org.junit.jupiter.api.Test;

public class BasicInOrderTest {
    @Test
    void testInOrder() {
        UserService mockUserService = mock(UserService.class);

        // Perform some interactions
        mockUserService.deleteUser("123");
        mockUserService.addUser("456");

        // Create an InOrder object for the mock
        InOrder inOrder = inOrder(mockUserService);

        // Verify the order of interactions
        inOrder.verify(mockUserService).deleteUser("123");
        inOrder.verify(mockUserService).addUser("456");
    }
}

class UserService {
    public void deleteUser(String userId) {
        // Method implementation
    }

    public void addUser(String userId) {
        // Method implementation
    }
}

Verifying Multiple Mocks

Verify the order of interactions on multiple mock objects.

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.verify;
import org.mockito.InOrder;
import org.junit.jupiter.api.Test;

public class MultipleInOrderTest {
    @Test
    void testInOrderMultipleMocks() {
        UserService mockUserService = mock(UserService.class);
        NotificationService mockNotificationService = mock(NotificationService.class);

        // Perform some interactions
        mockUserService.deleteUser("123");
        mockNotificationService.sendNotification("User 123 deleted");
        mockUserService.addUser("456");
        mockNotificationService.sendNotification("User 456 added");

        // Create an InOrder object for the mocks
        InOrder inOrder = inOrder(mockUserService, mockNotificationService);

        // Verify the order of interactions
        inOrder.verify(mockUserService).deleteUser("123");
        inOrder.verify(mockNotificationService).sendNotification("User 123 deleted");
        inOrder.verify(mockUserService).addUser("456");
        inOrder.verify(mockNotificationService).sendNotification("User 456 added");
    }
}

class UserService {
    public void deleteUser(String userId) {
        // Method implementation
    }

    public void addUser(String userId) {
        // Method implementation
    }
}

interface NotificationService {
    void sendNotification(String message);
}

Real-World Use Case

Ensuring Order of Operations in a Service

In a real-world scenario, you might have a service that interacts with multiple dependencies, and the order of these interactions is crucial. Using inOrder, you can ensure that methods are called in the correct sequence.

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.verify;
import org.mockito.InOrder;
import org.junit.jupiter.api.Test;

interface PaymentService {
    void processPayment(String orderId);
}

interface NotificationService {
    void sendNotification(String message);
}

class OrderService {
    private final PaymentService paymentService;
    private final NotificationService notificationService;

    public OrderService(PaymentService paymentService, NotificationService notificationService) {
        this.paymentService = paymentService;
        this.notificationService = notificationService;
    }

    public void placeOrder(String orderId) {
        paymentService.processPayment(orderId);
        notificationService.sendNotification("Order " + orderId + " placed");
    }

    public void cancelOrder(String orderId) {
        notificationService.sendNotification("Order " + orderId + " canceled");
    }
}

public class OrderServiceTest {
    @Test
    void testOrderServiceInteractionsInOrder() {
        PaymentService mockPaymentService = mock(PaymentService.class);
        NotificationService mockNotificationService = mock(NotificationService.class);
        OrderService orderService = new OrderService(mockPaymentService, mockNotificationService);

        // Call methods on OrderService
        orderService.placeOrder("123");
        orderService.cancelOrder("123");

        // Create an InOrder object for the mocks
        InOrder inOrder = inOrder(mockPaymentService, mockNotificationService);

        // Verify the order of interactions
        inOrder.verify(mockPaymentService).processPayment("123");
        inOrder.verify(mockNotificationService).sendNotification("Order 123 placed");
        inOrder.verify(mockNotificationService).sendNotification("Order 123 canceled");
    }
}

In this example, the OrderServiceTest class uses Mockito’s inOrder method to verify that interactions with PaymentService and NotificationService occur in the correct sequence. This helps ensure that the OrderService methods perform operations in the expected order.

Conclusion

The inOrder method in Mockito is used for verifying the order of interactions on mock objects. By using inOrder, you can ensure that methods are called in the correct sequence, which is essential for tests where the order of method calls is important. This helps improve the accuracy and reliability of your tests, ensuring that your code behaves as expected.