单元测试——PowerMock总结

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

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

      <dependency>
        <groupId>org.powermock</groupId>
        <artifactId>powermock-module-junit4</artifactId>
        <version>${powermock.version}</version>
        <scope>test</scope>
      </dependency>
      <dependency>
        <groupId>org.powermock</groupId>
        <artifactId>powermock-api-mockito</artifactId>
        <version>${powermock.version}</version>
        <scope>test</scope>
      </dependency>

普通POJO

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

普通Dao

public class UserDao {

    public int getCount(){
        throw new UnsupportedOperationException();
    }

    public void saveUser(User user){
        throw new UnsupportedOperationException();
    }

    /**
     * 静态方法
     */
    public static int removeUser(User user){
        throw new UnsupportedOperationException();
    }

}

普通Service

public class UserService {

    private UserDao userDao;

    public UserService(UserDao userDao) {
        this.userDao = userDao;
    }

    public int getUserCount() {
        return userDao.getCount();
    }

    public void saveUser(User user) {
        userDao.saveUser(user);
    }

    /**
     * 调用了静态方法
     */
    public int removeUser(User user) {
        return UserDao.removeUser(user);
    }

}

一、针对普通方法的测试

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

public class UserServiceTest {

    @Test
    public void getUserCountwithMockito() {
        UserDao userDao = Mockito.mock(UserDao.class);
        Mockito.when(userDao.getCount()).thenReturn(10);
        UserService userService = new UserService(userDao);
        int resutl = userService.getUserCount();
        Assert.assertEquals(10, resutl);
        Mockito.verify(userDao, Mockito.times(1)).getCount();
    }

    @Test
    public void getUserCountwithPowerMockito() {
        UserDao userDao = PowerMockito.mock(UserDao.class);
        PowerMockito.when(userDao.getCount()).thenReturn(5);
        UserService userService = new UserService(userDao);
        int resutl = userService.getUserCount();
        Assert.assertEquals(5, resutl);
    }

} 

 

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

public class UserServiceTest {

    @Test
    public void saveUserwithMock() {
//        User user = Mockito.mock(User.class);
        User user = new User();
        UserDao userDao = Mockito.mock(UserDao.class);
        Mockito.doNothing().when(userDao).saveUser(user);
        UserService userSerivce = new UserService(userDao);
        userSerivce.saveUser(user);
        Mockito.verify(userDao, Mockito.times(1)).saveUser(user);
    }


    @Test
    public void saveUserwithPowerMock() {
//        User user = new User();
        User user = PowerMockito.mock(User.class);
        UserDao userDao = PowerMockito.mock(UserDao.class);
        PowerMockito.doNothing().when(userDao).saveUser(user);
        UserService userService = new UserService(userDao);
        userService.saveUser(user);

    }

}  

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

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

@RunWith(PowerMockRunner.class)
@PrepareForTest({UserDao.class})
public class UserServiceTest {
    /**
     * 处理静态方法-PowerMock,在类上添加两个注解： 7      * @RunWith(PowerMockRunner.class)
     * @PrepareForTest(UserDao.class)
     */
    @Test
    public void removeUserwithPowerMock() {
        User user = PowerMockito.mock(User.class);
        PowerMockito.mockStatic(UserDao.class);
        PowerMockito.when(UserDao.removeUser(user)).thenReturn(1);
        UserService userService = new UserService(new UserDao());
        int result = userService.removeUser(user);
        Assert.assertEquals(1, result);
    }
}

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

普通POJO

import lombok.Getter;
import lombok.Setter;

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

}

 

普通Dao

public class EmployeeDao {

    public int getTotalCount(Employee employee) {
        throw new UnsupportedOperationException();
    }

    public void creatEmployee(Employee employee) {
        throw new UnsupportedOperationException();
    }

    public void updateEmployee(Employee employee) {
        throw new UnsupportedOperationException();
    }

    public int getEmployeeCount(Employee employee) {
        throw new UnsupportedOperationException();
    }

    public String getEmployeeByName(String name){
        throw new UnsupportedOperationException();
    }
}

 

普通Service

public class EmployeeService {

    /**
     * 局部变量：内部无参构造创建对象，整个方法有返回值
     */
    public int getTotalCount(Employee employee) {
        EmployeeDao employeeDao = new EmployeeDao();
        return employeeDao.getTotalCount(employee);
    }
    /**
     * 局部变量：内部无参构造创建对象，整个方法无返回值
     */
    public void createEmployee(Employee employee) {
        EmployeeDao employeeDao = new EmployeeDao();
        employeeDao.creatEmployee(employee);
    }

    /**
     * 方法内有分支
     */
    public void saveOrUpdate(Employee employee){
        EmployeeDao employeeDao = new EmployeeDao();
        int count = employeeDao.getEmployeeCount(employee);
        if(count>0){
            employeeDao.updateEmployee(employee);
        }else{
            employeeDao.creatEmployee(employee);
        }
    }
}

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)

@RunWith(PowerMockRunner.class)
@PrepareForTest(EmployeeService.class)
public class EmployeeServiceTest {

    /**
     * 测试有返回值，在类上添加两个注解：
     *
     * @RunWith(PowerMockRunner.class)
     * @PrepareForTest(EmployeeService.class)
     */
    @Test
    public void getTotalCountTest() {
        Employee employee = PowerMockito.mock(Employee.class);
        EmployeeDao employeeDao = PowerMockito.mock(EmployeeDao.class);
        try {
            PowerMockito.whenNew(EmployeeDao.class).withNoArguments().thenReturn(employeeDao);
            PowerMockito.when(employeeDao.getTotalCount(employee)).thenReturn(5);
            EmployeeService employeeService = new EmployeeService();
            int totalCount = employeeService.getTotalCount(employee);
            Assert.assertEquals(5, totalCount);
        } catch (Exception e) {
            fail("测试失败...");
        }
    }
}

3.2 测试无返回值

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

@RunWith(PowerMockRunner.class)
@PrepareForTest(EmployeeService.class)
public class EmployeeServiceTest {
    /**
     * 测试无返回值，在类上添加两个注解：
     *
     * @RunWith(PowerMockRunner.class)
     * @PrepareForTest(EmployeeService.class)
     */
    @Test
    public void creatEmplyeeTest() {
        Employee employee = PowerMockito.mock(Employee.class);

        EmployeeDao employeeDao = PowerMockito.mock(EmployeeDao.class);
        try {
            PowerMockito.whenNew(EmployeeDao.class).withNoArguments().thenReturn(employeeDao);
            PowerMockito.doNothing().when(employeeDao).creatEmployee(employee);
            EmployeeService employeeService = new EmployeeService();
            employeeService.createEmployee(employee);
            Mockito.verify(employeeDao, Mockito.times(1)).creatEmployee(employee);
        } catch (Exception e) {
            fail("测试失败...");
        }
    }
}

 3.3 通过Mockito.verify验证分支

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

@RunWith(PowerMockRunner.class)
@PrepareForTest(EmployeeService.class)
public class EmployeeServiceTest {
    /**
     * 测试分支及Mockito.verify，在类上添加两个注解：
     *
     * @RunWith(PowerMockRunner.class)
     * @PrepareForTest(EmployeeService.class)
     */
    @Test
    public void saveOrUpdateTest1() {
        Employee employee = PowerMockito.mock(Employee.class);
        EmployeeDao employeeDao = PowerMockito.mock(EmployeeDao.class);
        try {

            PowerMockito.whenNew(EmployeeDao.class).withNoArguments().thenReturn(employeeDao);
            PowerMockito.when(employeeDao.getEmployeeCount(employee)).thenReturn(0);

            EmployeeService employeeService = new EmployeeService();
            employeeService.saveOrUpdate(employee);

            Mockito.verify(employeeDao).creatEmployee(employee);
            Mockito.verify(employeeDao, Mockito.never()).updateEmployee(employee);
        } catch (Exception e) {
            fail("测试失败...");
        }
    }

    /**
     * 测试分支及Mockito.verify，在类上添加两个注解：
     *
     * @RunWith(PowerMockRunner.class)
     * @PrepareForTest(EmployeeService.class)
     */
    @Test
    public void saveOrUpdateTest2() {
        Employee employee = PowerMockito.mock(Employee.class);
        EmployeeDao employeeDao = PowerMockito.mock(EmployeeDao.class);
        try {

            PowerMockito.whenNew(EmployeeDao.class).withNoArguments().thenReturn(employeeDao);
            PowerMockito.when(employeeDao.getEmployeeCount(employee)).thenReturn(1);

            EmployeeService employeeService = new EmployeeService();
            employeeService.saveOrUpdate(employee);

            Mockito.verify(employeeDao, Mockito.never()).creatEmployee(employee);
            Mockito.verify(employeeDao).updateEmployee(employee);
        } catch (Exception e) {
            fail("测试失败...");
        }
    }
}

 四、参数使用

 4.1 org.mockito.Matchers使用

    /**
     * org.mockito.Matchers使用：Matchers.anyString()
     *
     * @RunWith(PowerMockRunner.class)
     * @PrepareForTest(EmployeeService.class)
     */
    @Test
    public void getEmployeeByNameTest1() throws Exception {
        EmployeeDao employeeDao = PowerMockito.mock(EmployeeDao.class);
        PowerMockito.whenNew(EmployeeDao.class).withNoArguments().thenReturn(employeeDao);
        PowerMockito.when(employeeDao.getEmployeeByName(Matchers.anyString())).thenReturn("hello");
        EmployeeService employeeService = new EmployeeService();
        employeeService.getEmployeeByName(Matchers.anyString());
    }

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;
}

@Test
    public void getEmployeeByNameTest3() throws Exception {
        EmployeeDao employeeDao = PowerMockito.mock(EmployeeDao.class);
        PowerMockito.whenNew(EmployeeDao.class).withNoArguments().thenReturn(employeeDao);
        /**
         * Example of stubbing a mock with custom answer:
         *
         * when(mock.someMethod(anyString())).thenAnswer(new Answer() {
         *     Object answer(InvocationOnMock invocation) {
         *         Object[] args = invocation.getArguments();
         *         Object mock = invocation.getMock();
         *         return "called with arguments: " + Arrays.toString(args);
         *     }
         * });
         */
        PowerMockito.when(employeeDao.getEmployeeByName(Mockito.anyString())).then(invocation ->{
            Object[] args = invocation.getArguments();
            System.out.println();
            System.out.println(invocation.getMethod());
            System.out.println(Arrays.asList(args));
            String value = (String)args[0];
            switch (value){
                case "one":return "hello one";
                case "two":return "hello two";
                case "three":return "hello three";
                default:
                    return new RuntimeException("Not support: " +  value );
            }
        });
        EmployeeService service = new EmployeeService();
        Assert.assertEquals("hello one", service.getEmployeeByName("one"));
        Assert.assertEquals("hello two", service.getEmployeeByName("two"));
        Assert.assertEquals("hello three", service.getEmployeeByName("three"));
        try {
            String others = service.getEmployeeByName("others");
        }catch (Exception e){
            Assert.assertTrue(e instanceof RuntimeException);
        }
    }

六、Spy使用和私有方法mock

普通Service

public class MyService {
    public void foo(String arg){
        this.printLog(arg);
    }
    private void printLog(String arg){
        System.out.println("hello " + arg);
    }

    public boolean exist(String args){
        return this.checkExist(args);
    }
    /**
     * 该方法做很多业务逻辑
     */
    private boolean checkExist(String args){
        throw new UnsupportedOperationException();
    }
}

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

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

源码如下：

/**
     * Allows to mock a private instance method based on method name and
     * parameters when stubbing in doThrow()|doAnswer()|doNothing()|doReturn()
     * style.
     * <p>
     * Example:
     * 
     * <pre>
     * doThrow(new RuntimeException()).when(instance, &quot;methodName&quot;, parameter1, parameter2);
     * </pre>
     * 
     * Read more about those methods:
     * <p>
     * {@link Mockito#doThrow(Throwable)}
     * <p>
     * {@link Mockito#doAnswer(Answer)}
     * <p>
     * {@link Mockito#doNothing()}
     * <p>
     * {@link Mockito#doReturn(Object)}
     * <p>
     * 
     * See examples in javadoc for {@link Mockito}
     */
    <T> void when(T mock, String methodToExpect, Object... arguments) throws Exception;

测试代码如下：

@RunWith(PowerMockRunner.class)
@PrepareForTest({MyService.class})
public class MyServiceTest {

    /**
     * ① 需要注解
     * @RunWith(PowerMockRunner.class)
     * @PrepareForTest({MyService.class})
     *
     * ② 私有方法checkExist可以mock
     *
     * ③参数必须同一个：都是world才能通过
     */
    @Test
    public void fooTest5() throws Exception {
        MyService service = PowerMockito.spy(new MyService());
        PowerMockito.doReturn(true).when(service, "checkExist", "world");
        Assert.assertTrue(service.exist("world"));
    }

    /**
     * 控制台打印输出：
     * hello other words
     */
    @Test
    public void fooTest4() {
        MyService service = PowerMockito.spy(new MyService());
        String arg = "world";
        PowerMockito.doNothing().when(service).foo(arg);
        service.foo("other words");
    }

    /**
     * 控制台无打印:doNothing()
     */
    @Test
    public void fooTest3() {
        MyService service = PowerMockito.spy(new MyService());
        String arg = "world";
        PowerMockito.doNothing().when(service).foo(arg);
        service.foo(arg);
    }

    /**
     * 控制台打印输出：spy(侦察)
     * hello world
     */
    @Test
    public void fooTest2() {
        MyService service = PowerMockito.spy(new MyService());
        service.foo("world");
    }

    /**
     * 控制台无打印：mock其实不去执行内部方法
     */
    @Test
    public void fooTest1() {
        MyService service = PowerMockito.mock(MyService.class);
        service.foo("world");
    }
}