Mockito+Junit5

实战

POM

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.nemo</groupId>
	<artifactId>demo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>demo</name>
	<description>Demo project for Spring Boot</description>
	<properties>
		<java.version>1.8</java.version>
	</properties>
	<dependencies>
		<dependency>
    		<groupId>org.mockito</groupId>
    		<artifactId>mockito-core</artifactId>
    		<version>4.4.0</version>
			<scope>test</scope>
		</dependency>

		<dependency>
    		<groupId>org.mockito</groupId>
    		<artifactId>mockito-inline</artifactId>
    		<version>4.4.0</version>
    		<scope>test</scope>
		</dependency>

		<dependency>
    		<groupId>org.junit.jupiter</groupId>
    		<artifactId>junit-jupiter-api</artifactId>
    		<version>5.8.2</version>
		</dependency>

		<dependency>
    		<groupId>org.projectlombok</groupId>
    		<artifactId>lombok</artifactId>
    		<version>1.18.22</version>
		</dependency>

	</dependencies>

</project>

TestDemo

public class TestDemo {

    @Autowired
    private TestRpcService testRPCService;

   public UserInfo getUser(Long id){

       if (id == null){
           throw new IllegalArgumentException();
       }

       try{
           UserInfo user = testRPCService.getUser(id);
           return user;
       }catch (Exception e){
           throw new RuntimeException();
       }
   }

   public void Test(){

   }
}

TestDemoTest（TestDemo的测试类）

class TestDemoTest {
    
    @InjectMocks
    //间谍。是基于一个真实的对象。Spy的所有方法都是真实的。通过Stub可以改变某个方法的行为
    @Spy
    private TestDemo testDemo;
    //基于某个接口或Class，创建一个假对象。对象的所有方法都是假的。通过Stub可以模拟某个方法的行为
    @Mock
    private TestRpcService testRPCService;
    
    @BeforeEach
    void setUp(){
        AutoCloseable autoCloseable = MockitoAnnotations.openMocks(this);
    }
    
    @Test
    void getUser() {
        
        //参数验证
        Long id = null;
        try{
            testDemo.getUser(id);
        }catch (Exception e){
            //验证是否抛出IllegalArgumentException
            Assertions.assertTrue(e instanceof IllegalArgumentException);
        }
        
        //静态方法
        id = TestUtil.testGetUserId();
        System.out.println("静态方法获取到用户id："+id);
        
        //mock掉静态方法的值
        MockedStatic<TestUtil> testUtilMock = Mockito.mockStatic(TestUtil.class);
        testUtilMock.when(()->TestUtil.testGetUserId()).thenReturn(2L);
        id = TestUtil.testGetUserId();
        System.out.println("mock静态方法获取到用户id："+id);
        
        //Mock Service正常运行
        UserInfo userInfo = getUserInfo(id);
        Mockito.when(testRPCService.getUser(id)).thenReturn(userInfo);
        userInfo = testDemo.getUser(id);
        //检验是否返回正确的结果
        Assertions.assertEquals(userInfo.getUserName(),"TEST1");
        Assertions.assertEquals(userInfo.getId(),2L);
        //mock的对象，getUserName方法，执行多次时，返回不同的值
        System.out.println("mock的用户信息第二次调用获得用户名："+userInfo.getUserName());
        
        //Mock Service异常运行
        Mockito.when(testRPCService.getUser(id)).thenThrow(new RuntimeException());
        try{
            testDemo.getUser(id);
        }catch (Exception e){
            //验证是否抛出RuntimeException
            Assertions.assertTrue(e instanceof RuntimeException);
        }
        
    }
    
    UserInfo getUserInfo(Long id) {
        UserInfo userInfo = mock(UserInfo.class);
        //同一个方法，执行多次时，返回不同的值
        Mockito.when(userInfo.getUserName())
            .thenReturn("TEST1")
            .thenReturn("TEST2")
            .thenReturn("TEST3");
        Mockito.when(userInfo.getId()).thenReturn(id);
        return userInfo;
    }
    
    @Test
    void test() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        //mock final
        TestService mockFinal = mock(TestService.class);
        when(mockFinal.testFinal()).thenReturn("mock final");
        System.out.println(mockFinal.testFinal());
        
        //mock static
        MockedStatic<TestService> mockStatic = Mockito.mockStatic(TestService.class);
        mockStatic.when(()->TestService.testStatic()).thenReturn("mock static");
        System.out.println(TestService.testStatic());
        
        //mock private
        TestService testService = new TestService();
        Method method = TestService.class.getDeclaredMethod("testPrivate");
        method.setAccessible(true);
        String returnValue = (String) method.invoke(testService);
        Assertions.assertEquals(returnValue, "private");
    }
}

TestRpcService

public interface TestRpcService {

    UserInfo getUser(Long id);

}

TestService

public class TestService {
    
    public final String testFinal(){
        return "final";
    }
    
    public static String testStatic(){
        return "static";
    }
    
    private String testPrivate(){
        return "private";
    }
    
}

TestUtil

public class TestUtil {

    public static Long testGetUserId(){
        return 1L;
    }
}

UserInfo

@Data
public class UserInfo {

    private Long Id;

    private String userName;
}