Show List
Tutorials > Mockito > Using Mockito to mock dependencies and collaborators

Using Mockito to mock dependencies and collaborators

Using Mockito to mock dependencies and collaborators involves creating mock objects for the classes or interfaces that your code depends on, so that you can test your code in isolation from those dependencies. This is useful when you want to test a specific piece of functionality in your code without having to rely on the behavior of other components that your code depends on. Here's an example of how to use Mockito to mock dependencies and collaborators:

Suppose you have the following class that depends on a UserService:

java
Copy code
public class UserController {
    private UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    public String getFullName(long userId) {
        User user = userService.getUserById(userId);
        return user.getFirstName() + " " + user.getLastName();
    }
}

To test the getFullName() method in isolation, you can create a mock object for the UserService interface using Mockito. Here's an example of how to do this:

java
Copy code
@Test
public void testGetFullName() {
    // Create the mock object
    UserService userService = mock(UserService.class);

    // Configure the mock object to return a specific user when getUserById() is called with a specific ID
    when(userService.getUserById(1L)).thenReturn(new User("John", "Doe"));

    // Create the UserController instance with the mock UserService
    UserController userController = new UserController(userService);

    // Call the getFullName() method and verify the result
    String fullName = userController.getFullName(1L);
    assertEquals("John Doe", fullName);

    // Verify that the getUserById() method was called with the correct argument
    verify(userService).getUserById(1L);
}

In this example, we create a mock object for the UserService interface using the mock() method provided by Mockito. We then configure the mock object to return a specific User object when its getUserById() method is called with an ID of 1L, as we did in the previous example. We then create an instance of the UserController class with the mock UserService and call its getFullName() method, which depends on the UserService instance. Mockito automatically injects the mock UserService into the UserController instance, so that we can test the getFullName() method in isolation from the UserService implementation. Finally, we verify that the getUserById() method was called with the correct argument using the verify() method.

Using Mockito to mock dependencies and collaborators in this way allows you to test your code in isolation and provides a way to test specific pieces of functionality without having to test the entire system. It also makes it easier to create tests that are reliable and repeatable, since you can control the behavior of the dependencies that your code relies on.



Next: Mocking static methods with Mockito

    Leave a Comment

  • captcha text