Junit，Mockito，PowerMockito 進行單元測試

文檔入口：

https://github.com/powermock/powermock/wiki

私有方法mock文檔：

https://github.com/powermock/powermock/wiki/MockPrivate

靜態方法mock文檔

https://github.com/powermock/powermock/wiki/MockStatic

案例參考：

https://ehlxr.me/2017/07/25/use-introduction-of-powermock/

 

概述：

    介紹基於Junit ，Mockito，PowerMockito 經常使用的測試方法，包括異常測試，私有方法測試，沒有返回值的方法測試，基於mock或spy的測試；

    其中包含常規方法mock，私有方法mock。

一 測試介紹

1）測試原則：

       凡是須要驗證的方法均可以寫單元測試，證實預期行爲（不區分 controller，service ，dao）

2）測試分類：

        a）單元測試：測試方法的 「邏輯」 是否知足指望。

        b）集成測試：集成各個依賴組件，測試總體流程是否能通。

3）關於依賴：

        單元測試通常測試當前方法的邏輯，不測試被依賴的類方法或本身的私有方法。

4）Mock 和 Spy 生成類區別

    Mock：生成的類，全部方法都不是真實的方法，並且返回值都是NULL； 經過when 指定行爲。

    Spy：生成的類，全部方法都是真實方法，返回值都是和真實方法同樣的；經過when 來將某個真實的方法，替換爲指定行爲的執行。

5）參考

            1）普通mockito mock

                http://site.mockito.org/

            2）使用powerMock ，加強 靜態方法，私有方法能力；

                https://github.com/powermock/powermock

二 Demo 本程序依賴

Xml代碼 

<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
    <modelVersion>4.0.0</modelVersion>  
   
    <groupId>x.test</groupId>  
    <artifactId>test</artifactId>  
    <version>1.0-SNAPSHOT</version>  
    <packaging>jar</packaging>  
   
    <name>test</name>  
    <url>http://maven.apache.org</url>  
   
    <properties>  
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
        <junit.version>4.12</junit.version>  
        <mockito.version>2.8.47</mockito.version>  
        <powermock.version>1.7.0</powermock.version>  
        <assertj.version>3.8.0</assertj.version>  
    </properties>  
   
    <dependencies>  
        <!-- test -->  
        <dependency>  
            <groupId>junit</groupId>  
            <artifactId>junit</artifactId>  
            <version>${junit.version}</version>  
            <scope>test</scope>  
        </dependency>  
        <dependency>  
            <groupId>org.mockito</groupId>  
            <artifactId>mockito-core</artifactId>  
            <version>${mockito.version}</version>  
            <scope>test</scope>  
        </dependency>  
        <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>  
        <dependency>  
            <groupId>org.assertj</groupId>  
            <artifactId>assertj-core</artifactId>  
            <version>${assertj.version}</version>  
            <scope>test</scope>  
        </dependency>  
        <!-- utils -->  
        <dependency>  
            <groupId>com.google.guava</groupId>  
            <artifactId>guava</artifactId>  
            <version>20.0</version>  
        </dependency>  
    </dependencies>  
    <build>  
        <plugins>  
            <plugin>  
                <groupId>org.apache.maven.plugins</groupId>  
                <artifactId>maven-compiler-plugin</artifactId>  
                <configuration>  
                    <source>1.8</source>  
                    <target>1.8</target>  
                </configuration>  
            </plugin>  
        </plugins>  
   
    </build>  
</project>

 

三 簡單的測試

    測試拋異常，無返回值的方法測試，私有方法測試

1）被測試類

Java代碼 

package x.test.simple;  
   
import com.google.common.base.Strings;  
   
/** 
* 測試demo class 
* <p> 
* Created by shilei on 2017/7/10. 
*/  
public class HelloWho {  
   
    private String who;  
   
    public HelloWho(String who) {  
        //條件路徑  
        if (Strings.isNullOrEmpty(who)) {  
            throw new IllegalArgumentException("who can not be null!");  
        }  
        //賦值路徑  
        this.who = who;  
    }  
   
    public void sayHello() {  
        System.out.println(getHelloMessage());  
    }  
   
   
    private String getHelloMessage() {  
        return "Hello " + who;  
    }  
}

 

2）測試類

Java代碼 

package x.test.simple;  
  
import org.assertj.core.api.Assertions;  
import org.junit.Test;  
import org.powermock.reflect.Whitebox;  
  
/** 
 * 基礎測試： 
 * <p> 
 * 1 測試拋異常 
 * 2 測試無返回值 
 * 3 測試私有方法 
 */  
public class HelloWhoTest {  
  
  
    @Test(expected = IllegalArgumentException.class)  
    public void test_construction_empty_who_throw_exception() {  
        new HelloWho("");  
    }  
  
    @Test(expected = IllegalArgumentException.class)  
    public void test_construction_null_who_throw_exception() {  
        new HelloWho(null);  
    }  
  
    /** 
     * 無返回值的方法測試，查看其修改的成員變量是否成功 
     */  
    @Test  
    public void test_construction_args_set_who() throws Exception {  
        //預期結果  
        String expectWho = "A";  
  
        //執行被測試方法  
        HelloWho helloWho = new HelloWho(expectWho);  
  
        //白盒，獲取修改的成員變量  
        String actualWho = (String) Whitebox.getField(helloWho.getClass(), "who").get(helloWho);  
  
        //斷言  
        Assertions.assertThat(actualWho).isEqualTo(expectWho);  
    }  
  
    /** 
     * 測試私有方法 
     */  
    @Test  
    public void test_getHelloMessage() throws Exception {  
        //準備方法參數  
        String who = "A";  
  
        //準備預期結構  
        String expextMessage = "Hello " + who;  
  
        //執行被測試方法  
        HelloWho helloWho = new HelloWho(who);  
        String actualMessage = Whitebox.invokeMethod(helloWho, "getHelloMessage");  
  
        //斷言  
        Assertions.assertThat(actualMessage).isEqualTo(expextMessage);  
    }  
  
}

 

四 基於Mock的測試

    依賴mock，私有方法mock，驗證方法是否被執行

1）被依賴類Dao

Java代碼 

package x.test.adv.dao.pojo;  
   
/** 
* 用戶 
* <p> 
* Created by shilei on 2017/7/10. 
*/  
public class User {  
   
}  
   
package x.test.adv.dao;  
   
   
import x.test.adv.dao.pojo.User;  
   
/** 
* 用戶dao 
* Created by shilei on 2017/7/10. 
*/  
public interface UserDao {  
   
    /** 
     * 保存 
     * 
     * @param user 用戶 
     * @return true : 保存成功 ； false ： 用戶已存在 
     */  
    boolean save(User user);  
}

 

2）待測試類Service

Java代碼 

package x.test.adv.service;  
   
import x.test.adv.dao.pojo.User;  
   
/** 
* 用戶服務 
* <p> 
* Created by shilei on 2017/7/10. 
*/  
public interface UserService {  
   
    /** 
     * 保存 ， 若是保存成功，記錄日誌 
     * 
     * @param user user 
     */  
    void save(User user);  
}  
   
package x.test.adv.service.impl;  
   
import x.test.adv.dao.UserDao;  
import x.test.adv.dao.pojo.User;  
import x.test.adv.service.UserService;  
   
/** 
* 帶依賴的測試 
* <p> 
* Created by shilei on 2017/7/10. 
*/  
public class UserServiceImpl implements UserService {  
   
    private UserDao userDao;  
   
    @Override  
    public void save(User user) {  
        //保存  
        boolean isSave = userDao.save(user);  
   
        //寫大數據日誌  
        if (isSave) {  
            writeLog(user);  
        }  
   
    }  
   
    private void writeLog(User user) {  
        System.out.println(user);  
    }  
   
}

 

3）測試類

Java代碼 

package x.test.adv.service.impl;  
   
import org.junit.Before;  
import org.junit.Test;  
import org.junit.runner.RunWith;  
import org.mockito.InjectMocks;  
import org.mockito.Mock;  
import org.mockito.Mockito;  
import org.mockito.MockitoAnnotations;  
import org.powermock.api.mockito.PowerMockito;  
import org.powermock.core.classloader.annotations.PrepareForTest;  
import org.powermock.modules.junit4.PowerMockRunner;  
import x.test.adv.dao.UserDao;  
import x.test.adv.dao.pojo.User;  
   
/** 
* 帶依賴的測試： 
* 1 mock 依賴 
* 2 mock 私有方法 
*/  
@RunWith(PowerMockRunner.class)  
//mock 靜態方法，私有方法，須要添加該註解，以便通知框架  
@PrepareForTest(UserServiceImpl.class)  
public class UserServiceImplTest {  
   
    //mock 依賴注入到該bean  
    @InjectMocks  
    private UserServiceImpl userServiceImpl;  
   
    //mock 依賴  
    @Mock  
    private UserDao userDao;  
   
    //完成依賴注入  
    @Before  
    public void setUp() {  
        MockitoAnnotations.initMocks(this);  
    }  
   
    /** 
     * 測試保存成功，寫日誌 
     */  
    @Test  
    public void test_save_true_verify_writelog() throws Exception {  
        // 偵查對象  
        UserServiceImpl spyUserService = PowerMockito.spy(userServiceImpl);  
   
        //建立輸入  
        User user = new User();  
   
        //打樁  
        // mock 依賴行爲，等價於  BDDMockito.given(userDao.save(user)).willReturn(true);  
        Mockito.when(userDao.save(user)).thenReturn(true);  
        //mock 私有方法  
        PowerMockito.doNothing().when(spyUserService, "writeLog", user);  
   
        //調用實際方法  
        spyUserService.save(user);  
   
        //斷言 writelog 被執行一次  
        PowerMockito.verifyPrivate(spyUserService, Mockito.times(1)).invoke("writeLog", user);  
    }  
   
    /** 
     * 測試保存成功，寫日誌 
     */  
    @Test  
    public void test_save_false_no_writelog() throws Exception{  
        // 偵查對象  
        UserServiceImpl spyUserService = PowerMockito.spy(userServiceImpl);  
   
        //建立輸入  
        User user = new User();  
   
        //打樁  
        // mock 依賴行爲，等價於  BDDMockito.given(userDao.save(user)).willReturn(true);  
        Mockito.when(userDao.save(user)).thenReturn(false);  
        //mock 私有方法  
        PowerMockito.doNothing().when(spyUserService, "writeLog", user);  
   
        //調用實際方法  
        spyUserService.save(user);  
   
        //斷言 writelog 被執行一次  
        PowerMockito.verifyPrivate(spyUserService, Mockito.times(0)).invoke("writeLog", user);  
    }  
}