PowerMock笔记-三种方式对比

PowerMock主要研究如下：

引用依赖

 <properties>
        <powermock.version>1.7.1</powermock.version>
    </properties>
    <dependencies>
        <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-mockito2</artifactId>
            <version>${powermock.version}</version>
            <scope>test</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.20</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

import lombok.Data;

/**
 * @author chenjianfei
 */
@Data
public class Employee {
    private String name;
    private Integer age;
}

import vip.fkandy.powermock.common.Employee;

/**
 * @author chenjianfei
 */
public class EmployeeDao {
    /**
     * 查询员工数
     *
     * @return
     */
    public int getEmployeeCount() {
        throw new UnsupportedOperationException();
    }

    /**
     * 添加员工
     *
     * @param employee
     */
    public void addEmployee(Employee employee) {
        throw new UnsupportedOperationException();
    }
}

import vip.fkandy.powermock.common.Employee;

/**
 * @author chenjianfei
 */
public class EmployeeService {
    private EmployeeDao employeeDao;

    /**
     * 通过构造方法注入
     *
     * @param employeeDao
     */
    public EmployeeService(EmployeeDao employeeDao) {
        this.employeeDao = employeeDao;
    }

    /**
     * 获取员工人数
     *
     * @return
     */
    public int getEmployeeCount() {
        return employeeDao.getEmployeeCount();
    }

    /**
     * 添加新员工
     *
     * @param employee
     */
    public void addEmployee(Employee employee) {
        employeeDao.addEmployee(employee);
    }

}

junit测试

import org.junit.Before;
import org.junit.Test;
import vip.fkandy.powermock.common.Employee;

import static org.junit.Assert.*;

public class EmployeeServiceTest_junit {

    private EmployeeService employeeService;

    @Before
    public void setUp() {
        employeeService = new EmployeeService(new EmployeeDao());
    }

    /**
     * Junit测试查找Count方法
     */
    @Test
    public void testGetTotalEmployeeWithJunit() {
        try {
            int count = employeeService.getEmployeeCount();
            fail("should not process to here");
        } catch (Exception e) {
            assertTrue(e instanceof UnsupportedOperationException);
        }
    }

    /**
     * Junit测试添加员工方法
     */
    @Test
    public void testaddEmployeeWithJunit() {
        try {
            employeeService.addEmployee(new Employee());
            fail("should not process to here");
        } catch (Exception e) {
            assertTrue(e instanceof UnsupportedOperationException);
        }
    }
}

Mockito测试

import org.junit.Ignore;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.powermock.api.mockito.PowerMockito;
import vip.fkandy.powermock.common.Employee;

import static org.junit.Assert.*;

public class EmployeeServiceTest_mockito {

    @Mock
    private EmployeeDao employeeDao;

    @Test
    public void testGetTotalEmployeeWithMockito() {
        MockitoAnnotations.initMocks(this);
        Mockito.when(employeeDao.getEmployeeCount()).thenReturn(10);
        EmployeeService service = new EmployeeService(employeeDao);
        int total = service.getEmployeeCount();
        assertEquals(10, total);
    }

    @Ignore
    @Test
    public void testCreateEmployeeWithMockito() {
        MockitoAnnotations.initMocks(this);
        Employee employee = new Employee();
        EmployeeService service = new EmployeeService(employeeDao);
        service.addEmployee(employee);
        Mockito.verify(employeeDao).addEmployee(employee);
    }
}

PowerMock测试

import org.junit.Ignore;
import org.junit.Test;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import vip.fkandy.powermock.common.Employee;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;

public class EmployeeServiceTest_powerMock {

    /**
     * do...when...then
     */
    @Test
    public void testGetTotalEmployeeWithPowerMock() {
        EmployeeDao employeeDao = PowerMockito.mock(EmployeeDao.class);
        PowerMockito.when(employeeDao.getEmployeeCount()).thenReturn(10);
        EmployeeService service = new EmployeeService(employeeDao);
        int total = service.getEmployeeCount();
        assertEquals(10, total);
    }

    @Ignore
    @Test
    public void testCreateEmployeeWithMockito() {
        EmployeeDao employeeDao = PowerMockito.mock(EmployeeDao.class);
        Employee employee = new Employee();
        PowerMockito.doNothing().when(employeeDao).addEmployee(employee);
        EmployeeService service = new EmployeeService(employeeDao);
        service.addEmployee(employee);
        //针对没有返回值的测试方式,判断方法是否顺序调用过一次
        Mockito.verify(employeeDao).addEmployee(employee);
    }
}