9+ Mockito 使い方 For You

Mockito 3 Ways to Init Mock in JUnit 5 Mincong Huang from mincong.io

Introduction

Mockito is a popular open-source testing framework used by Java developers to write effective unit tests. With Mockito, developers can easily create mock objects and carry out unit testing without the need for a real database or network connection. In this article, we will delve into the basics of Mockito and its usage to create efficient unit tests for your Java application.

What is Mockito?

Mockito is a Java-based testing framework that allows developers to create mock objects, stubs, and spies. These objects can be used in place of real objects for testing purposes, allowing developers to test the functionality of their code without relying on external dependencies. Mockito is easy to use and can be integrated into a wide range of Java applications.

Mockito Basics

Mockito provides a set of methods that allow developers to create mock objects. These objects are created using the Mockito.mock() method, which takes the class or interface to be mocked as a parameter. For example, to create a mock object for the UserDao interface, you would use the following code:

 UserDao userDaoMock = Mockito.mock(UserDao.class);

Once created, mock objects can be used to simulate the behavior of real objects. Developers can use Mockito's when() method to define the behavior of mock objects. For example, to define the behavior of a mock UserDao object to return a specific user when the findById() method is called, you would use the following code:

 when(userDaoMock.findById(1L)).thenReturn(new User(1L, "John", "Doe"));

Mockito Annotations

Mockito also provides a set of annotations that can be used to simplify the creation and management of mock objects. The @Mock annotation can be used to create a mock object, and the @InjectMocks annotation can be used to inject mock objects into the target object. For example:

 @Mock UserDao userDaoMock; @InjectMocks UserService userService; @BeforeEach public void setUp() { MockitoAnnotations.initMocks(this); } @Test public void testFindUserById() { when(userDaoMock.findById(1L)).thenReturn(new User(1L, "John", "Doe")); User user = userService.findUserById(1L); assertEquals("John", user.getName()); }

Mockito Verify

Mockito's verify() method can be used to check if a method was called on a mock object. This is useful when verifying that certain methods are being called with the correct arguments. For example:

 verify(userDaoMock).findById(1L);

This code will verify that the findById() method was called on the userDaoMock object with the argument 1L.

Mockito Spy

Mockito's spy() method can be used to create a spy object. Spy objects are real objects that have been partially mocked. Developers can use Mockito's when() method to define the behavior of the spy object for specific methods. For example:

 UserDao userDao = new UserDaoImpl(); UserDao userDaoSpy = Mockito.spy(userDao); when(userDaoSpy.findById(1L)).thenReturn(new User(1L, "John", "Doe"));

In this code, a UserDaoImpl object is created and then partially mocked using the spy() method. The findById() method is then defined to return a specific user when called on the spy object.

Conclusion

Mockito is a powerful testing framework that can help developers write efficient and effective unit tests. By creating mock objects, developers can simulate the behavior of real objects and test their code without relying on external dependencies. With its simple syntax and powerful features, Mockito is a must-have tool for any Java developer looking to create robust unit tests.