JMockit、Mockito和Powermock介绍

郑帅

2023-12-01

前言

最近看到公司项目里用到了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却弥补了这一点，它是无所不能的，正如其名字一样。

JMockit、Mockito和Powermock介绍

前言

一、JMockit使用

1. 引入依赖

2. @Mocked与@Injectable

3. JMockit的record（录制）---- replay（回放） ---- verify（验证）

二、Mockito使用

1. 引入依赖

2. 举例说明

三、PowerMock使用

1. 引入依赖

2. 举例说明

总结

相关阅读

相关文章

相关问答

相关文档