单元测试——PowerMock总结

最近项目中单元测试覆盖率要求越来越高，之前Junit和Mock已经无法胜任，所以引入了更强大的PowerMock，方便我们解决静态方法，私有方法等。因此，本文输出PowerMock作为实际使用的小结。

maven项目引入依赖（版本号看实际需要）

 1       <dependency>
 2         <groupId>org.powermock</groupId>
 3         <artifactId>powermock-module-junit4</artifactId>
 4         <version>${powermock.version}</version>
 5         <scope>test</scope>
 6       </dependency>
 7       <dependency>
 8         <groupId>org.powermock</groupId>
 9         <artifactId>powermock-api-mockito</artifactId>
10         <version>${powermock.version}</version>
11         <scope>test</scope>
12       </dependency>

普通POJO

public class User {
    private String name;
    private String password;
}

普通Dao

 1 public class UserDao {
 2 
 3     public int getCount(){
 4         throw new UnsupportedOperationException();
 5     }
 6 
 7     public void saveUser(User user){
 8         throw new UnsupportedOperationException();
 9     }
10 
11     /**
12      * 静态方法
13      */
14     public static int removeUser(User user){
15         throw new UnsupportedOperationException();
16     }
17 
18 }

普通Service

 1 public class UserService {
 2 
 3     private UserDao userDao;
 4 
 5     public UserService(UserDao userDao) {
 6         this.userDao = userDao;
 7     }
 8 
 9     public int getUserCount() {
10         return userDao.getCount();
11     }
12 
13     public void saveUser(User user) {
14         userDao.saveUser(user);
15     }
16 
17     /**
18      * 调用了静态方法
19      */
20     public int removeUser(User user) {
21         return UserDao.removeUser(user);
22     }
23 
24 }

一、针对普通方法的测试

（1）有参返回——Mock和PowerMock都能处理

 1 public class UserServiceTest {
 2 
 3     @Test
 4     public void getUserCountwithMockito() {
 5         UserDao userDao = Mockito.mock(UserDao.class);
 6         Mockito.when(userDao.getCount()).thenReturn(10);
 7         UserService userService = new UserService(userDao);
 8         int resutl = userService.getUserCount();
 9         Assert.assertEquals(10, resutl);
10         Mockito.verify(userDao, Mockito.times(1)).getCount();
11     }
12 
13     @Test
14     public void getUserCountwithPowerMockito() {
15         UserDao userDao = PowerMockito.mock(UserDao.class);
16         PowerMockito.when(userDao.getCount()).thenReturn(5);
17         UserService userService = new UserService(userDao);
18         int resutl = userService.getUserCount();
19         Assert.assertEquals(5, resutl);
20     }
21 
22 }

（2）无参返回——Mock和PowerMock都能处理

 1 public class UserServiceTest {
 2 
 3     @Test
 4     public void saveUserwithMock() {
 5 //        User user = Mockito.mock(User.class);
 6         User user = new User();
 7         UserDao userDao = Mockito.mock(UserDao.class);
 8         Mockito.doNothing().when(userDao).saveUser(user);
 9         UserService userSerivce = new UserService(userDao);
10         userSerivce.saveUser(user);
11         Mockito.verify(userDao, Mockito.times(1)).saveUser(user);
12     }
13 
14 
15     @Test
16     public void saveUserwithPowerMock() {
17 //        User user = new User();
18         User user = PowerMockito.mock(User.class);
19         UserDao userDao = PowerMockito.mock(UserDao.class);
20         PowerMockito.doNothing().when(userDao).saveUser(user);
21         UserService userService = new UserService(userDao);
22         userService.saveUser(user);
23 
24     }
25 
26 }

二、针对静态方法——只能用PowerMock处理了

当调用UserDao的静态方法时，通过@PrepareForTest注解提前准备好一个UserDao类。

 1 @RunWith(PowerMockRunner.class)
 2 @PrepareForTest({UserDao.class})
 3 public class UserServiceTest {
 4     /**
 5      * 处理静态方法-PowerMock,在类上添加两个注解： 7      * @RunWith(PowerMockRunner.class)
 8      * @PrepareForTest(UserDao.class)
 9      */
10     @Test
11     public void removeUserwithPowerMock() {
12         User user = PowerMockito.mock(User.class);
13         PowerMockito.mockStatic(UserDao.class);
14         PowerMockito.when(UserDao.removeUser(user)).thenReturn(1);
15         UserService userService = new UserService(new UserDao());
16         int result = userService.removeUser(user);
17         Assert.assertEquals(1, result);
18     }
19 }

三、局部变量——只能用PowerMock处理了

普通POJO

import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
public class Employee {
    private String name;
    private String password;

}

普通Dao

 1 public class EmployeeDao {
 2 
 3     public int getTotalCount(Employee employee) {
 4         throw new UnsupportedOperationException();
 5     }
 6 
 7     public void creatEmployee(Employee employee) {
 8         throw new UnsupportedOperationException();
 9     }
10 
11     public void updateEmployee(Employee employee) {
12         throw new UnsupportedOperationException();
13     }
14 
15     public int getEmployeeCount(Employee employee) {
16         throw new UnsupportedOperationException();
17     }
18 
19     public String getEmployeeByName(String name){
20         throw new UnsupportedOperationException();
21     }
22 }

普通Service

 1 public class EmployeeService {
 2 
 3     /**
 4      * 局部变量：内部无参构造创建对象，整个方法有返回值
 5      */
 6     public int getTotalCount(Employee employee) {
 7         EmployeeDao employeeDao = new EmployeeDao();
 8         return employeeDao.getTotalCount(employee);
 9     }
10     /**
11      * 局部变量：内部无参构造创建对象，整个方法无返回值
12      */
13     public void createEmployee(Employee employee) {
14         EmployeeDao employeeDao = new EmployeeDao();
15         employeeDao.creatEmployee(employee);
16     }
17 
18     /**
19      * 方法内有分支
20      */
21     public void saveOrUpdate(Employee employee){
22         EmployeeDao employeeDao = new EmployeeDao();
23         int count = employeeDao.getEmployeeCount(employee);
24         if(count>0){
25             employeeDao.updateEmployee(employee);
26         }else{
27             employeeDao.creatEmployee(employee);
28         }
29     }
30 }

3.1 测试“有返回值”

@PrepareForTest(EmployeeService.class)：让创建出来的EmployeeService实例，采用事先准备好的（@PrepareForTest帮助实现，底层通过改变字节码）。

PowerMockito.whenNew(EmployeeDao.class).withNoArguments().thenReturn(employeeDao)：利用PowerMockito创建无参构造类的实例（通过mock已经准备，如PowerMockito.mock(Employee.class)

）,其中 withNoArguments()会抛异常，需要try...catch处理。

构造函数说明

（1）PowerMockito.whenNew(EmployeeDao.class).withNoArguments()
（2）PowerMockito.whenNew(EmployeeDao.class).withAnyArguments()
（3）PowerMockito.whenNew(EmployeeDao.class).withArguments(Object firstArgument, Object... additionalArguments)

 1 @RunWith(PowerMockRunner.class)
 2 @PrepareForTest(EmployeeService.class)
 3 public class EmployeeServiceTest {
 4 
 5     /**
 6      * 测试有返回值，在类上添加两个注解：
 7      *
 8      * @RunWith(PowerMockRunner.class)
 9      * @PrepareForTest(EmployeeService.class)
10      */
11     @Test
12     public void getTotalCountTest() {
13         Employee employee = PowerMockito.mock(Employee.class);
14         EmployeeDao employeeDao = PowerMockito.mock(EmployeeDao.class);
15         try {
16             PowerMockito.whenNew(EmployeeDao.class).withNoArguments().thenReturn(employeeDao);
17             PowerMockito.when(employeeDao.getTotalCount(employee)).thenReturn(5);
18             EmployeeService employeeService = new EmployeeService();
19             int totalCount = employeeService.getTotalCount(employee);
20             Assert.assertEquals(5, totalCount);
21         } catch (Exception e) {
22             fail("测试失败...");
23         }
24     }
25 }

3.2 测试无返回值

PowerMockito.doNothing().when(employeeDao).creatEmployee(employee);

 1 @RunWith(PowerMockRunner.class)
 2 @PrepareForTest(EmployeeService.class)
 3 public class EmployeeServiceTest {
 4     /**
 5      * 测试无返回值，在类上添加两个注解：
 6      *
 7      * @RunWith(PowerMockRunner.class)
 8      * @PrepareForTest(EmployeeService.class)
 9      */
10     @Test
11     public void creatEmplyeeTest() {
12         Employee employee = PowerMockito.mock(Employee.class);
13 
14         EmployeeDao employeeDao = PowerMockito.mock(EmployeeDao.class);
15         try {
16             PowerMockito.whenNew(EmployeeDao.class).withNoArguments().thenReturn(employeeDao);
17             PowerMockito.doNothing().when(employeeDao).creatEmployee(employee);
18             EmployeeService employeeService = new EmployeeService();
19             employeeService.createEmployee(employee);
20             Mockito.verify(employeeDao, Mockito.times(1)).creatEmployee(employee);
21         } catch (Exception e) {
22             fail("测试失败...");
23         }
24     }
25 }

3.3 通过Mockito.verify验证分支

　　通过PowerMockito.when(employeeDao.getEmployeeCount(employee)).thenReturn(0)：中thenReturn的返回值可以走向不同的分支。

 1 @RunWith(PowerMockRunner.class)
 2 @PrepareForTest(EmployeeService.class)
 3 public class EmployeeServiceTest {
 4     /**
 5      * 测试分支及Mockito.verify，在类上添加两个注解：
 6      *
 7      * @RunWith(PowerMockRunner.class)
 8      * @PrepareForTest(EmployeeService.class)
 9      */
10     @Test
11     public void saveOrUpdateTest1() {
12         Employee employee = PowerMockito.mock(Employee.class);
13         EmployeeDao employeeDao = PowerMockito.mock(EmployeeDao.class);
14         try {
15 
16             PowerMockito.whenNew(EmployeeDao.class).withNoArguments().thenReturn(employeeDao);
17             PowerMockito.when(employeeDao.getEmployeeCount(employee)).thenReturn(0);
18 
19             EmployeeService employeeService = new EmployeeService();
20             employeeService.saveOrUpdate(employee);
21 
22             Mockito.verify(employeeDao).creatEmployee(employee);
23             Mockito.verify(employeeDao, Mockito.never()).updateEmployee(employee);
24         } catch (Exception e) {
25             fail("测试失败...");
26         }
27     }
28 
29     /**
30      * 测试分支及Mockito.verify，在类上添加两个注解：
31      *
32      * @RunWith(PowerMockRunner.class)
33      * @PrepareForTest(EmployeeService.class)
34      */
35     @Test
36     public void saveOrUpdateTest2() {
37         Employee employee = PowerMockito.mock(Employee.class);
38         EmployeeDao employeeDao = PowerMockito.mock(EmployeeDao.class);
39         try {
40 
41             PowerMockito.whenNew(EmployeeDao.class).withNoArguments().thenReturn(employeeDao);
42             PowerMockito.when(employeeDao.getEmployeeCount(employee)).thenReturn(1);
43 
44             EmployeeService employeeService = new EmployeeService();
45             employeeService.saveOrUpdate(employee);
46 
47             Mockito.verify(employeeDao, Mockito.never()).creatEmployee(employee);
48             Mockito.verify(employeeDao).updateEmployee(employee);
49         } catch (Exception e) {
50             fail("测试失败...");
51         }
52     }
53 }

四、参数使用

4.1 org.mockito.Matchers使用

 1     /**
 2      * org.mockito.Matchers使用：Matchers.anyString()
 3      *
 4      * @RunWith(PowerMockRunner.class)
 5      * @PrepareForTest(EmployeeService.class)
 6      */
 7     @Test
 8     public void getEmployeeByNameTest1() throws Exception {
 9         EmployeeDao employeeDao = PowerMockito.mock(EmployeeDao.class);
10         PowerMockito.whenNew(EmployeeDao.class).withNoArguments().thenReturn(employeeDao);
11         PowerMockito.when(employeeDao.getEmployeeByName(Matchers.anyString())).thenReturn("hello");
12         EmployeeService employeeService = new EmployeeService();
13         employeeService.getEmployeeByName(Matchers.anyString());
14     }

4.2 ArgumentMatcher使用

注意还使用了Matchers.argThat(new MyArgumentMatcher())

    /**
     * ArgumentMatcher使用
     *
     * @RunWith(PowerMockRunner.class)
     * @PrepareForTest(EmployeeService.class)
     */
    @Test
    public void getEmployeeByNameTest2() throws Exception {
        EmployeeDao employeeDao = PowerMockito.mock(EmployeeDao.class);
        PowerMockito.whenNew(EmployeeDao.class).withNoArguments().thenReturn(employeeDao);
        PowerMockito.when(employeeDao.getEmployeeByName(Matchers.argThat(new MyArgumentMatcher()))).thenReturn("hello");
        EmployeeService service = new EmployeeService();

        Assert.assertEquals("hello", service.getEmployeeByName("selectOne"));
        Assert.assertEquals("hello", service.getEmployeeByName("selectTwo"));
        Assert.assertEquals("hello", service.getEmployeeByName("selectThree"));
        /**
         * 如果采用其他String就会报错，如下：
         * Assert.assertEquals("hello",service.getEmployeeByName("Others"));
         */
    }

    private class MyArgumentMatcher extends ArgumentMatcher<String> {

        @Override
        public boolean matches(Object argument) {
            String value = (String) argument;
            switch (value) {
                case "selectOne":
                case "selectTwo":
                case "selectThree":
                    return true;
                default:
                    return false;
            }
        }
    }

五、Answer接口使用

public interface Answer<T> {
    /**
     * @param invocation the invocation on the mock.
     *
     * @return the value to be returned
     *
     * @throws Throwable the throwable to be thrown
     */
    T answer(InvocationOnMock invocation) throws Throwable;
}

 1 @Test
 2     public void getEmployeeByNameTest3() throws Exception {
 3         EmployeeDao employeeDao = PowerMockito.mock(EmployeeDao.class);
 4         PowerMockito.whenNew(EmployeeDao.class).withNoArguments().thenReturn(employeeDao);
 5         /**
 6          * Example of stubbing a mock with custom answer:
 7          *
 8          * when(mock.someMethod(anyString())).thenAnswer(new Answer() {
 9          *     Object answer(InvocationOnMock invocation) {
10          *         Object[] args = invocation.getArguments();
11          *         Object mock = invocation.getMock();
12          *         return "called with arguments: " + Arrays.toString(args);
13          *     }
14          * });
15          */
16         PowerMockito.when(employeeDao.getEmployeeByName(Mockito.anyString())).then(invocation ->{
17             Object[] args = invocation.getArguments();
18             System.out.println();
19             System.out.println(invocation.getMethod());
20             System.out.println(Arrays.asList(args));
21             String value = (String)args[0];
22             switch (value){
23                 case "one":return "hello one";
24                 case "two":return "hello two";
25                 case "three":return "hello three";
26                 default:
27                     return new RuntimeException("Not support: " +  value );
28             }
29         });
30         EmployeeService service = new EmployeeService();
31         Assert.assertEquals("hello one", service.getEmployeeByName("one"));
32         Assert.assertEquals("hello two", service.getEmployeeByName("two"));
33         Assert.assertEquals("hello three", service.getEmployeeByName("three"));
34         try {
35             String others = service.getEmployeeByName("others");
36         }catch (Exception e){
37             Assert.assertTrue(e instanceof RuntimeException);
38         }
39     }

六、Spy使用和私有方法mock

普通Service

 1 public class MyService {
 2     public void foo(String arg){
 3         this.printLog(arg);
 4     }
 5     private void printLog(String arg){
 6         System.out.println("hello " + arg);
 7     }
 8 
 9     public boolean exist(String args){
10         return this.checkExist(args);
11     }
12     /**
13      * 该方法做很多业务逻辑
14      */
15     private boolean checkExist(String args){
16         throw new UnsupportedOperationException();
17     }
18 }

（1）mock与spy区别：mock不去内部执行，而spy会；spy也可以不执行,如：PowerMockito.doNothing().when(service).foo(arg)

（2）私有方法也可以mock：PowerMockito.doReturn(true).when(service, "checkExist", "world");

源码如下：

 1 /**
 2      * Allows to mock a private instance method based on method name and
 3      * parameters when stubbing in doThrow()|doAnswer()|doNothing()|doReturn()
 4      * style.
 5      * <p>
 6      * Example:
 7      * 
 8      * <pre>
 9      * doThrow(new RuntimeException()).when(instance, &quot;methodName&quot;, parameter1, parameter2);
10      * </pre>
11      * 
12      * Read more about those methods:
13      * <p>
14      * {@link Mockito#doThrow(Throwable)}
15      * <p>
16      * {@link Mockito#doAnswer(Answer)}
17      * <p>
18      * {@link Mockito#doNothing()}
19      * <p>
20      * {@link Mockito#doReturn(Object)}
21      * <p>
22      * 
23      * See examples in javadoc for {@link Mockito}
24      */
25     <T> void when(T mock, String methodToExpect, Object... arguments) throws Exception;

测试代码如下：

 1 @RunWith(PowerMockRunner.class)
 2 @PrepareForTest({MyService.class})
 3 public class MyServiceTest {
 4 
 5     /**
 6      * ① 需要注解
 7      * @RunWith(PowerMockRunner.class)
 8      * @PrepareForTest({MyService.class})
 9      *
10      * ② 私有方法checkExist可以mock
11      *
12      * ③参数必须同一个：都是world才能通过
13      */
14     @Test
15     public void fooTest5() throws Exception {
16         MyService service = PowerMockito.spy(new MyService());
17         PowerMockito.doReturn(true).when(service, "checkExist", "world");
18         Assert.assertTrue(service.exist("world"));
19     }
20 
21     /**
22      * 控制台打印输出：
23      * hello other words
24      */
25     @Test
26     public void fooTest4() {
27         MyService service = PowerMockito.spy(new MyService());
28         String arg = "world";
29         PowerMockito.doNothing().when(service).foo(arg);
30         service.foo("other words");
31     }
32 
33     /**
34      * 控制台无打印:doNothing()
35      */
36     @Test
37     public void fooTest3() {
38         MyService service = PowerMockito.spy(new MyService());
39         String arg = "world";
40         PowerMockito.doNothing().when(service).foo(arg);
41         service.foo(arg);
42     }
43 
44     /**
45      * 控制台打印输出：spy(侦察)
46      * hello world
47      */
48     @Test
49     public void fooTest2() {
50         MyService service = PowerMockito.spy(new MyService());
51         service.foo("world");
52     }
53 
54     /**
55      * 控制台无打印：mock其实不去执行内部方法
56      */
57     @Test
58     public void fooTest1() {
59         MyService service = PowerMockito.mock(MyService.class);
60         service.foo("world");
61     }
62 }