前言

最近看到公司專案里用到了JMockit的框架測驗，結合以往使用的Mockito和PowerMock來分析一下三者分別是如何使用的，

一、JMockit使用

1. 引入依賴

<dependency>
	<groupId>org.jmockit</groupId>
	<artifactId>jmockit</artifactId>
	<version>1.31</version>
	<scope>test</scope>
</dependency>

<!-- 此依賴用于注解@BeforeMethod和@Test -->
<dependency>
    <groupId>org.testng</groupId>
    <artifactId>testng</artifactId>
    <version>RELEASE</version>
    <scope>test</scope>
</dependency>

<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<version>4.11</version>
	<scope>test</scope>
</dependency>

2. @Mocked與@Injectable

關于二者的區別，這篇博客JMokit中的@Mocked與@Injectable區別說得比較詳細，這里不再贅述，需要注意的是對于靜態方法和構造方法，@Injectable并不起作用，而@Mocked照樣起作用，另外，@Injectable與@Tested是搭配使用的，如果使用了@Tested和@Mocked集合，會報錯，因為@Tested找不到@Injectable注解的實體去初始化構造方法（親測），可通過測驗方法@Injectable實體化引數來解決，

3. JMockit的record（錄制）---- replay（回放） ---- verify（驗證）

package com.demo.core.jmockit;

import com.demo.api.bean.dto.BookBaseDto;
import com.demo.api.bean.po.User;
import com.demo.api.service.IBuyBookService;
import com.demo.core.Service.UserService;
import com.demo.core.dao.UserDao;
import com.demo.core.utils.DateUtils;
import mockit.*;
import org.junit.Assert;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;

import java.text.ParseException;
import java.util.*;


public class TestCase {

    @Mocked
    private UserDao userDao;

    @Injectable
    private IBuyBookService buyBookService;

    //@Tested注解的不是interface，而是具體實作類
    @Tested
    private UserService service;

    private UserService userService;

    //在測驗方法之前運行
    @BeforeMethod
    private void setUp() {
        userService = new UserService();
    }

    @Test
    public void testQueryUserListByUsername(@Injectable final UserDao udao) {
        final List<User> userList = Collections.singletonList(new User("admin", "pwd123", 25));
        //對于一些類的私有成員屬性可以通過設值的方式來注入
        Deencapsulation.setField(userService, "userDao", userDao);
        //錄制腳本
        new Expectations() {
            {
                //需要錄制的方法呼叫
                userDao.selectUserListByUserName(anyString);
                //錄制的回傳結果
                result = userList;
            }
        };

        //回放階段
        List<User> users = userService.queryUserListByUsername("admin");
        Assert.assertEquals(1, users.size());

        //驗證階段(匿名內部類)
        new Verifications() {
            {
                userService.queryUserListByUsername(anyString);
                //呼叫次數
                times = 1;
            }
        };
    }

    /**
     * mockUp
     * 當我們只需要mock某個類的某一個方法，對于其他方法我們正常呼叫
     */
    @Test
    public void testMockUp(@Injectable final UserDao udao) {
        new MockUp<UserService>() {
            @Mock
            public String viewUsername(String username) {
                return "guest";
            }
        };
        Assert.assertEquals("guest", userService.viewUsername("admin"));
        Assert.assertEquals(23, userService.viewAge(23));
    }

    /**
     * JMockit的另一個強大之處，可以mock靜態方法（功能和PowerMock有的一比）
     */
    @Test
    public void testStaticMethod(@Injectable final UserDao udao) throws ParseException {
        final String currentTime = "2020-09-20 15:40:00";
        new Expectations(DateUtils.class) {
            {
                DateUtils.dateToString((Date) any);
                result = currentTime;
            }
        };
        Assert.assertEquals(currentTime, DateUtils.dateToString(new Date()));
    }

    /**
     * mock私有屬性
     */
    @Test
    public void testPrivateField(@Injectable final UserDao udao) {
        Deencapsulation.setField(userService, "books", 2);
        Assert.assertEquals(4, userService.sumBook(2));
    }

    /**
     * mock私有方法
     */
    @Test
    public void testPrivateMethod(@Injectable final UserDao udao) {
        Object invoke = Deencapsulation.invoke(userService, "putUsername", "admin");
        Assert.assertEquals("admin", invoke);
    }

    /**
     * 模擬@Test和@Injectable集合使用
     */
    @Test
    public void testCalculatePrice(@Injectable final UserDao udao) {
        new Expectations() {
            {
                buyBookService.doBookPrice((BookBaseDto) any);
                result = 48.00;
                times = 1;
            }
        };
        Deencapsulation.setField(service, "books", 2);
        Object price = service.calculatePrice();
        Assert.assertEquals(96.00, price);
    }

}

UserService代碼如下：

@Service
@Slf4j
public class UserService implements IUserService {

    @Autowired
    private UserDao userDao;

    private int books;

    @Override
    public List<User> queryUserListByUsername(String username) {
        List<User> userList = userDao.selectUserListByUserName(username);
        if (CollectionUtils.isEmpty(userList)) {
            log.warn("查詢用戶資訊為空");
            return null;
        }
        return userList;
    }

    @Override
    public int updateUserByParams(User user) {
        List<User> userList = userDao.selectUserListByUserName(user.getUsername());
        if (CollectionUtils.isEmpty(userList)) {
            log.warn("根據用戶名" + user.getUsername() + "查詢用戶資訊為空...");
            return 0;
        }
        return userDao.updateUserByParams(user);
    }

    @Override
    public String viewUsername(String username) {
        return username;
    }

    @Override
    public int viewAge(int age) {
        return age;
    }

    public int sumBook(int count) {
        int myCount = this.buyBook();
        return myCount + count;
    }

    private int buyBook(){
        return this.books;
    }

    private String putUsername(String username) {
        return username;
    }
	
	public double calculatePrice() {
        BookBaseDto baseDto = AnimationBook.builder()
                .bookName("動物世界")
                .animationPrice(20)
                .build();
        Object price = buyBookService.doBookPrice(baseDto);
        return (double) price * this.books;
    }
}

DateUtils代碼如下：

@Slf4j
public class DateUtils {
	private static final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

	public static String dateToString (Date date) throws ParseException {
        if (date == null) {
            return null;
        }
        synchronized (dateFormat) {
            return dateFormat.format(date);
        }
    }
}

一般來說@Capturing不經常使用，下面單獨舉例說明一下，其中AnimationBookService和MythologyBookService分別實作IMemberStrategyService介面，

package com.demo.core.jmockit;

import com.demo.api.bean.dto.AnimationBook;
import com.demo.api.bean.dto.MythologyBook;
import com.demo.api.service.IMemberStrategyService;
import com.demo.core.Service.AnimationBookService;
import com.demo.core.Service.MythologyBookService;
import mockit.Capturing;
import mockit.Expectations;
import org.junit.Assert;
import org.testng.annotations.Test;

public class TestCapturing {

    @Capturing
    private IMemberStrategyService memberStrategyService;

    /**
     * 模擬@Capturing
     */
    @Test
    public void testCapturing() {
        IMemberStrategyService animationBookService = new AnimationBookService();
        IMemberStrategyService mythologyBookService = new MythologyBookService();
        new Expectations() {
            {
                memberStrategyService.calcPrice(any);
                result = 40.00;
            }
        };
        Object animationPrice = animationBookService.calcPrice(AnimationBook.builder().bookName("動物世界").animationPrice(20).build());
        Object mythologyPrice = mythologyBookService.calcPrice(MythologyBook.builder().bookName("神話故事").mythologyPrice(10).build());

        //不管IMemberStrategyService的實作類是哪個，計算的價格都是40.00
        Assert.assertEquals(40.00, animationPrice);
        Assert.assertEquals(40.00, mythologyPrice);
    }
}

package com.demo.api.service;

public interface IMemberStrategyService<T> {

    /**
     * 計算圖書的價格
     * @param bookType 不同的圖書
     * @return 計算出打折后的價格
     */
    double calcPrice(T bookType);
}

JMockit小結:

對@Tested物件判斷是否為null，是則通過合適構造器初始化， @Injectable的實體會自動注入到@Tested中，
當只知道父類或介面，但需要控制它所有子類的行為時，子類可能有多個實作，就用@Capturing，
MockUp只能模擬類，不能模擬介面

二、Mockito使用

1. 引入依賴

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-all</artifactId>
    <version>1.10.19</version>
    <scope>test</scope>
</dependency>

<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<version>4.11</version>
	<scope>test</scope>
</dependency>

2. 舉例說明

首先引入MockMvc，對模塊進行集成測驗時，希望能夠通過輸入URL對Controller進行測驗，如果通過啟動服務器，建立http client進行測驗，這樣會使得測驗變得很麻煩，比如，啟動速度慢，測驗驗證不方便，依賴網路環境等，所以為了可以對Controller進行測驗，我們引入了MockMVC，因為Mockito和PowerMock的使用方式基本一樣，所以具體使用和下面的PowerMock一起說明，

package com.ssm.web.controller;

import com.google.common.collect.Lists;
import com.ssm.po.User;
import com.ssm.service.IUserService;
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.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;

import java.util.List;

import static org.mockito.Mockito.verify;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:test-application-context.xml", "classpath:test-spring-mvc.xml"})
public class LoginUserControllerTest {

    private MockMvc mockMvc;

    @InjectMocks//創建一個實體，其余用@Mock（或@Spy）注解創建的mock將被注入到用該實體中
    private static LoginUserController loginUserController;

    @Mock
    private IUserService userService;

    @Before
    public void before() {
    	//不適用@Mock注解也可以使用如下方式mock
    	//userService = mock(IUserService.class);
        //這句話執行以后，userService自動注入到loginUserController中，
        //在這之后，你就可以放心大膽地使用when().then()等進行更詳細的設定
        MockitoAnnotations.initMocks(this);
        mockMvc = MockMvcBuilders.standaloneSetup(loginUserController).build();
    }

	/**
     * MockMvc方法決議
     * perform：執行一個RequestBuilder請求，會自動執行SpringMvc的流程并映射到相應的控制器執行處理
     * get：宣告發送一個get請求方法，MockHttpServletRequestBuilder get(Sring urlTemple, Object… urlVariables)：根據url模板和url變數值得到一個GET請求方式的，另外提供了其他的請求方法，如：POST、PUT、DELETE等
     * param：添加request的引數，如上面發送請求的時候戴上了pcode=root的引數，假如使用需要發送json資料格式的時候將不能使用這種方式，
     * andExpect：添加ResultMatcher驗證規則，驗證控制器執行完成后結果是否正確（對回傳的資料進行的判斷）
     * andDo：添加ResultHandler結果處理器，比如除錯時列印結果到控制臺（對回傳的資料進行的判斷）
     * andReturn：最后回傳相應的MvcResult：然后進行自定義驗證/進行下一步例外處理（對回傳的資料進行的判斷）
     * contentType 指定org.springframework.http.MediaType 指定請求引數型別json之類的
     * @throws Exception
     */
    @Test
    public void testCheckLoginUser() throws Exception{
        List<User> userList = Lists.newArrayList();
        User user = new User();
        user.setAge(10);
        user.setUsername("Jay Chen");
        user.setPassword("admin");
        userList.add(user);

        Mockito.when(userService.queryUserListByUsername(Mockito.anyString())).thenReturn(userList);
        mockMvc.perform(get("/cf/queryUserList")
                .param("username", "chen"))
                .andExpect(status().isOk())
                .andReturn();
        verify(userService).queryUserListByUsername(Mockito.anyString());
    }
}

Mockito小結:

在單元測驗中使用@Mock, @Spy, @InjectMocks等注解時，需要進行初始化后才能使用，
MockitoAnnotations.initMocks(this)，其中this就是單元測驗所在的類，在initMocks函式中Mockito會根據類中不同的注解（如@Mock, @Spy等）創建不同的mock物件，即初始化作業

三、PowerMock使用

1. 引入依賴

<dependency>
    <groupId>org.powermock</groupId>
    <artifactId>powermock-module-junit4</artifactId>
    <version>1.7.4</version>
    <scope>test</scope>
</dependency>

<dependency>
    <groupId>org.powermock</groupId>
    <artifactId>powermock-api-mockito</artifactId>
    <version>1.7.0</version>
    <scope>test</scope>
</dependency>

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-all</artifactId>
    <version>1.10.19</version>
    <scope>test</scope>
</dependency>

<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<version>4.11</version>
	<scope>test</scope>
</dependency>

一般情況下，PowerMock結合Mockito一起使用，需要注意的是，PowerMock和Mockito會存在jar包版本的沖突，詳情可見此鏈接，(https://www.linkedin.com/pulse/mockito-2x-over-powermock-migration-tips-tricks-top-ten-hazem-saleh?trk=seokp-post-title)

2. 舉例說明

package com.demo.core.powermock;

import com.demo.api.bean.po.User;
import com.demo.api.service.IBuyBookService;
import com.demo.api.service.IUserService;
import com.demo.core.Service.UserService;
import com.demo.core.dao.UserDao;
import com.demo.core.utils.DateUtils;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.powermock.reflect.Whitebox;
import org.springframework.test.util.ReflectionTestUtils;

import java.lang.reflect.Method;
import java.text.ParseException;
import java.util.Arrays;
import java.util.Date;
import java.util.List;



/**
 * @RunWith(PowerMockRunner.class)陳述句告訴JUnit用PowerMockRunner來執行測驗，
 * @PrepareForTest(DateUtils.class)陳述句告訴PowerMock準備DateUtils類進行測驗，
 * 適用于模擬final類或有final, private, static, native方法的類，
 **/
@RunWith(PowerMockRunner.class)
@PrepareForTest({DateUtils.class})//如果注解在某個測驗方法上，單個的測驗類會初始化錯誤(親測)
public class UserServiceTest {

    private IUserService userService;

    @Mock
    private UserDao userDao;

    @Mock
    private IBuyBookService buyBookService;

    @Before
    public void setUp() {
        userService = new UserService();
        userDao = PowerMockito.mock(UserDao.class);
        ReflectionTestUtils.setField(userService, "userDao", userDao);

        buyBookService = PowerMockito.mock(IBuyBookService.class);
        ReflectionTestUtils.setField(userService, "buyBookService", buyBookService);
    }

    /**
     * 一般使用方式
     * @throws Exception
     */
    @Test
    public void testQueryUserListByUsername() throws Exception {
        List<User> userList = Arrays.asList(new User("chen", "admin", 25), new User("fei", "24", 24));
        PowerMockito.when(userDao.selectUserListByUserName(Mockito.anyString())).thenReturn(userList);
        //測驗拋出例外
        //PowerMockito.when(userDao.selectUserListByUserName(Mockito.anyString())).thenThrow(new RuntimeException());
        List<User> users = userService.queryUserListByUsername("chen");
        Assert.assertEquals(2, users.size());
    }

    /**
     * 靜態方法mock
     * @throws ParseException
     */
    @Test
    public void testStaticMethod() throws ParseException {
        String date = "2020-09-20 15:40:00";
        PowerMockito.mockStatic(DateUtils.class);
        PowerMockito.when(DateUtils.dateToString(Mockito.any((Date.class)))).thenReturn(date);
        Assert.assertEquals(date, userService.getTime());
    }

    /**
     * mock私有屬性
     */
    @Test
    public void testPrivateField() throws IllegalAccessException {
        PowerMockito.field(UserService.class, "books").set(userService, 2);
        Assert.assertEquals(2, userService.viewBooks(1));
    }

    /**
     * 測驗私有方法一
     */
    @Test
    public void testPrivateMethod() throws Exception {
        //此種方式一般在public或protected方法中mock私有方法
        //PowerMockito.doReturn("admin").when(userService, "putUsername", "admin");

        //第一個引數是私有方法所在類，第二個引數是私有方法名，第三個引數是私有方法引數
        Method method = PowerMockito.method(UserService.class, "putUsername", String.class);
        Object invoke = method.invoke(userService, "admin");
        Assert.assertEquals("admin", invoke);
    }

    /**
     * 測驗私有方法二
     */
    @Test
    public void testPrivateMethod_2() throws Exception {
        Object obj = Whitebox.invokeMethod(userService, "putUsername", "admin");
        Assert.assertEquals("admin", obj);
    }

}

總結

從上面JMockit和PowerMock的舉例來看，二者的功能非常相似，用法也很相近，都可以對靜態方法或屬性以及對私有方法進行mock，不過可以看到，JMockit的使用比起PowerMock更加輕量級，不需要對類進行整個注解，只需在單個測驗用例中使用即可，PowerMock相當于是Mockito的升級版，Mockito不能實作對靜態方法的mock，而PowerMock卻彌補了這一點，它是無所不能的，正如其名字一樣，

轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/97185.html

標籤：其他

上一篇：作業一年不會JVM調優，丟人嗎？？？

下一篇：從零學ELK系列（十一）:SpringBoot專案接入ELK超級版（超詳細圖文教程）

JMockit、Mockito和Powermock介紹

前言

一、JMockit使用

1. 引入依賴

2. @Mocked與@Injectable

3. JMockit的record（錄制）---- replay（回放） ---- verify（驗證）

二、Mockito使用

1. 引入依賴

2. 舉例說明

三、PowerMock使用

1. 引入依賴

2. 舉例說明

總結