看完点个赞呗,难道想白嫖不成?更多内容请访问微信公众号 :三国测,扫码关注哟!

原文链接:http://www.cnblogs.com/zishi/p/6760272.html

Mock工具Jmockit使用介绍

在写单元测试的过程中我们会发现需要测试的类有很多依赖,这些依赖的类或者资源又会有依赖,导致在单元测试代码里无法完成构建,我们应对的方法是Mock。简单的说就是模拟这些需要构建的类或者资源,提供给需要测试的对象使用。

1、Mock工具概述

1.1 mock工具列表

可用的Mock Toolkit有许多,比较常见的有EasyMock, Jmock和JMockit等等,到底选哪个呢,Jmockit的官网上有个特性对比列表,很详细,他们的功能对比如下:

Feature

EasyMock

jMock

Mockito

Unitils Mock

PowerMock:
EasyMock
API

PowerMock:
Mockito
API

JMock
it

Invocation count constraints

 

Recording strict expectations

   

 

Explicit verification

   

 

Partial mocking

 

No method call to switch from
record to replay

   

 

No extra code for implicit
verification

   

N/A

N/A

 

N/A

No extra "prepare for test"
code

   

No need to use @RunWith annotation or base
test class

     

Consistent syntax between void and non-void methods

 

 

   

Argument matchers for some parameters
only,
not all

     

   

Easier argument matching based
on properties
of value objects

 

Cascading mocks

   

 

Support for mocking multiple
interfaces

   

   

Support for mocking annotation
types

 

 

Partially ordered expectations

 

       

Mocking of constructors and final/static/native/private
methods

       

Declarative application of
mocks/stubs to
whole test classes

       

Auto-injection of mocks

   

 

Mocking of "new-ed" objects

       

Support for mocking enum types

       

Declarative mocks for the test class
(mock
fields)

   

Declarative mocks for test
methods
(parameters, local fields)

           

Special fields for
"any" argument matching

           

Use of an special field to
specify invocation
results

           

Use of special fields to
specify invocation
count constraints

           

Expectations with custom error
messages

           

On-demand mocking of
unspecified implementation classes

           

Capture of instances created by
code under
test

           

Recording & verification of
expectations in
loops

           

Support for covariant return
types

           

"Duck typing" mocks
for state-based tests

           

Single jar file in the classpath is
sufficient to
use mocking API

   

 

N/A

N/A

Total

6/32

7/32

13/31

11/31

9/31

14/30

32/32

Total when ignoring JMockit-only
features

6/22

7/22

13/21

11/21

9/21

14/20

22/22

1.2 Mockito简介

EasyMock 以及 Mockito 都因为可以极大地简化单元测试的书写过程而被许多人应用在自己的工作中,但是这两种 Mock 工具都不可以实现对静态函数、构造函数、私有函数、Final 函数以及系统函数的模拟,但是这些方法往往是我们在大型系统中需要的功能。

关于更多Mockito2.0新特性,参考官方介绍文档,里边有关于为什么不mock private的原因,挺有意思的:

https://github.com/mockito/mockito/wiki/What%27s-new-in-Mockito-2

Mockito 的使用

###Maven###

通过Maven管理的,需要在项目的Pom.xml中增加如下的依赖:

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

在程序中可以import org.mockito.Mockito,然后调用它的static方法。

1.2.1 模拟对象

创建 Mock 对象的语法为 mock(class or interface)。

1.2.2 设置对象调用的预期返回值

通过 when(mock.someMethod()).thenReturn(value) 来设定 Mock 对象某个方法调用时的返回值。或者使用 when(mock.someMethod()).thenThrow(new RuntimeException) 的方式来设定当调用某个方法时抛出的异常。

1.2.3 验证被测试类方法

Mock 对象一旦建立便会自动记录自己的交互行为,所以我们可以有选择的对它的 交互行为进行验证。在 Mockito 中验证 Mock 对象交互行为的方法是 verify(mock).someMethod(…)。最后 Assert() 验证返回值是否和预期一样。

1.2.4 Demo

Mock 对象的创建

 mock(Class classToMock);
mock(Class classToMock, String name)
mock(Class classToMock, Answer defaultAnswer)
mock(Class classToMock, MockSettings mockSettings)
mock(Class classToMock, ReturnValues returnValues)

可以对类和接口进行mock对象的创建,创建时可以为mock对象命名。对mock对象命名的好处是调试的时候容易辨认mock对象。

Mock对象的期望行为和返回值设定

假设我们创建了LinkedList类的mock对象:

LinkedList mockedList = mock(LinkedList.class);

1.3 PowerMock简介

PowerMock 是在 EasyMock 以及 Mockito 基础上的扩展,通过定制类加载器等技术,PowerMock 实现了之前提到的所有模拟功能,使其成为大型系统上单元测试中的必备工具。缺点是缺少文档。

mock是模拟对象,用于模拟真实对象的行为。

Powermock主要用于打桩。比如:方法A的参数需要传入实例B,方法A需要调用B的某个方法B.C()。方法C因为耗时长或者根本没有实现或者其他不方便在单元测试中实现等原因,需要伪造返回,此时Powermock即可派上用场。

PowerMock扩展了EasyMock和Mockito框架,增加了对static和final方法mock支持等功能。这里主要基于PowerMock Mockito API进行介绍。

PowerMock支持JUnit和TestNG,这里基于JUnit。

安装

下载地址:https://github.com/jayway/powermock/wiki/Downloads。下载" Mockito and JUnit including dependencies"版本。当前版本为”powermock-mockito-junit-1.6.3.zip"。

1.4 Stub和Mock

###Mock###
所谓的mock,即模拟,模仿的意思。Mock 技术的主要作用是使用mock工具模拟一些在应用中不容易构造或者比较复杂的对象,从而把测试目标与测试边界以外的对象隔离开。

###Stub###
Stub,桩。单元测试过程中,对于在应用中不容易构造或者比较复杂的对象,用一个虚拟的对象来代替它。从类的实现方式上看,stub有一个显式的类实现,按照stub类的复用层次可以实现为普通类(被多个测试案例复用),内部类(被同一个测试案例的多个测试方法复用)乃至内部匿名类(只用于当前测试方法)。stub的方法也会有具体的实现,哪怕简单到只有一个简单的return语句。

###Stub 与 Mock 的区别###
Stub 是在单元测试过程中去代替某些对象来提供所需的测试数据,适用于基于状态的(state-based)测试,关注的是输入和输出。而Mock适用于基于交互的(interaction-based)测试,关注的是交互过程,不只是模拟状态,还能够模拟模块或对象的行为逻辑并能验证其正确性,Mock不需要类的显示实现,直接用工具模拟。

2、Jmockit安装

综合考量下来,所以我们的mock工具也选择了jmockit(http://jmockit.org/index.html

关于如何使用:

推荐:在Maven 的pom.xml文件中添加以下依赖节点:

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

当然也可以在项目中直接引入jar包。

3、如何创建一个 mock 对象

JMockit模拟API可用于JUnit 4(版本4.5或更高版本),JUnit 5或TestNG(版本6.2或更高版本)编写测试。 现在让我们看看这个API是如何进行模拟的,为了便于理解,下面引用官网给出的范例代码,同时我们将必要的类库进行引用。

在测试类中,声明一个你想要模拟的类型的mock字段,并用@Mocked,@Injectable或@Capturing注释。当模拟类时,@Injectable意味着只有被分配mock字段的实例将具有mock行为; 否则,被mock的类的所有实例将被mock。

import org.junit.*;
import mockit.*; public class MyFirstJMockitTest
{
// Mocked实例(而不是常规的“mock对象”)将自动创建并分配到带注释的mock字段
@Mocked
Collaborator mock1; //所有当前和未来的实例都会被mock
@Injectable
AnotherDependency anotherMock; //只有一个特定实例被mock @Test
public void myFirstTestMethod()
{
//任何mock字段都可以在这里或者类的任何其他测试方法中使用
} @Test
public void testMethodWithMockParameter(@Mocked YetAnotherDependency testSpecificMock)
{
...
} ...
}

注意:上面的测试类显示了一些不同的东西:第二个测试方法声明一个参数! 通常,JUnit / TestNG测试方法不允许有参数。 然而,当使用JMockit时,允许这样的模拟参数。 一般来说,只有测试类中大多数或所有测试都需要Mock类型时,才使用测试类的Mock字段。 否则,Mock的范围最好仅限于单个测试的Mock参数。 JMockit将总是关注实例化Mock类型,并且当测试运行器调用测试方法时,将实例分配给mock字段(假设字段不是final)或将其作为参数传递。

4、Mock范例1

要Mock测试的方法如下:

public class MyObject {
public String hello(String name){
return "Hello " + name;
}
}

使用JMockit编写的单元测试如下:

@Mocked  //用@Mocked标注的对象,不需要赋值,jmockit自动mock
MyObject obj; @Test
public void testHello() {
new NonStrictExpectations() {//录制预期模拟行为
{
obj.hello("Zhangsan");
returns("Hello Zhangsan");
//也可以使用:result = "Hello Zhangsan";
}
};
assertEquals("Hello Zhangsan", obj.hello("Zhangsan"));//调用测试方法
new Verifications() {//验证预期Mock行为被调用
{
obj.hello("Hello Zhangsan");
times = 1;
}
};
}

代码完成后,运行单元测试,结果如下:

JMockit也可以分类为非局部模拟与局部模拟,区分在于Expectations块是否有参数,有参数的是局部模拟,反之是非局部模拟。

而Expectations块一般由Expectations类和NonStrictExpectations类定义,类似于EasyMock和PowerMock中的Strict Mock和一般性Mock。

用Expectations类定义的,则mock对象在运行时只能按照 Expectations块中定义的顺序依次调用方法,不能多调用也不能少调用,所以可以省略掉Verifications块;

而用NonStrictExpectations类定义的,则没有这些限制,所以如果需要验证,则要添加Verifications块。

上述的例子使用了非局部模拟,下面我们使用局部模拟来改写上面的测试,代码如下:

@Test
public void testHello() {
final MyObject obj = new MyObject();
new NonStrictExpectations(obj) {//录制预期模拟行为
{
obj.hello("Zhangsan");
returns("Hello Zhangsan");
//也可以使用:result = "Hello Zhangsan";
}
};
assertEquals("Hello Zhangsan", obj.hello("Zhangsan"));//调用测试方法
new Verifications() {//验证预期Mock行为被调用
{
obj.hello("Hello Zhangsan");
times = 1;
}
};
}

模拟静态方法:

@Test
public void testMockStaticMethod() {
new NonStrictExpectations(ClassMocked.class) {
{
ClassMocked.getDouble(1);//也可以使用参数匹配:ClassMocked.getDouble(anyDouble);
result = 3;
}
}; assertEquals(3, ClassMocked.getDouble(1)); new Verifications() {
{
ClassMocked.getDouble(1);
times = 1;
}
};
}

模拟私有方法:

如果ClassMocked类中的getTripleString(int)方法指定调用一个私有的multiply3(int)的方法,我们可以使用如下方式来Mock:

@Test
public void testMockPrivateMethod() throws Exception {
final ClassMocked obj = new ClassMocked();
new NonStrictExpectations(obj) {
{
this.invoke(obj, "multiply3", 1);//如果私有方法是静态的,可以使用:this.invoke(null, "multiply3")
result = 4;
}
}; String actual = obj.getTripleString(1);
assertEquals("4", actual); new Verifications() {
{
this.invoke(obj, "multiply3", 1);
times = 1;
}
};
}

5、Mock案例2

接下来我们用Jmockit实现一个具体的单元测试,首先下面是一段Controller的功能代码:

import com.odde.mail.model.Result;
import com.odde.mail.service.MailService;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.codehaus.jackson.map.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody; import static java.lang.String.format; @Controller
@RequestMapping("/mail")
public class MailController {
private static final Log log = LogFactory.getLog(MailController.class);
private final ObjectMapper mapper = new ObjectMapper(); @Autowired
private MailService mailService; @RequestMapping(value = "/send", method = RequestMethod.POST, produces = "text/plain;charset=UTF-8")
public
@ResponseBody
String send(@RequestParam("recipients") String recipients,
@RequestParam("subject") String subject,
@RequestParam("content") String content) throws Exception {
log.debug("mail controller send start");
log.debug(format("recipients:%s", recipients));
log.debug(format("subject:%s", subject));
log.debug(format("content:%s", content));
Result mailResult = mailService.send(recipients, subject, content);
String result = mapper.writeValueAsString(mailResult);
log.debug(format("result:%s", result));
log.debug("mail controller send finish");
return result;
}
}

接下来我们看一下Jmockit实现的具体的单元测试代码:

import com.odde.mail.model.Result;
import com.odde.mail.service.MailService;
import mockit.Expectations;
import mockit.Injectable;
import mockit.Tested;
import mockit.integration.junit4.JMockit;
import org.junit.Test;
import org.junit.runner.RunWith;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat; @RunWith(JMockit.class)
public class MailControllerTest {
@Tested
MailController mailController;
@Injectable
private MailService mailService;
@Test
public void should_return_status_success_when_send_mail_success() throws Exception {
new Expectations() { {
mailService.send("test@test.com", "test", "test");
result = new Result("成功");
} };
String result = mailController.send("test@test.com", "test", "test");
assertThat(result, is("{\"status\":\"成功\"}"));
}
}
  • @RunWith(JMockit.class): 指定单元测试的执行类为JMockit.class;
  • @Tested: 这个是指被测试类,在这个测试案例中我们要测试的是MailController,所以我们给其打上这个标签;
  • @Injectable: 这个可以将对象进行mock并自动关联到被测试类,而不需要通过其他文件类似spring的配置文件等来进行关联;
  • @Expectations: mock对象mailService的send方法,让其返回一个Result对象;

做完上面这些基本就可以了,后面的被测方法调用和验证都跟原来的一样。这样看起来是不是比原来的单元测试代码少了一些,也更简洁了一些,最重要的一点是这样的单元测试不依赖spring的bean定义文件,不需要启动web服务,执行起来速度很快。

6、Mock案例3

首先仍然是先看一下Service的功能代码,代码也比较简单,就是调用Repository做一些增删改查的动作。

import com.odde.mail.model.Recipient;
import com.odde.mail.model.Result;
import com.odde.mail.repo.RecipientRepository;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service; import java.util.List; @Service
public class RecipientService { @Autowired
private RecipientRepository recipientRepository; public Result add(String username, String email) {
Recipient recipient = recipientRepository.findByEmail(email);
Result result;
if (recipient == null) {
recipientRepository.save(new Recipient(username, email));
result = new Result("成功");
} else {
result = new Result("失败");
}
return result;
}
}

接着就是它的单元测试代码,我们看一下Jmockit如何实现的mock代码:

import com.odde.mail.model.Recipient;
import com.odde.mail.model.Result;
import com.odde.mail.repo.RecipientRepository;
import mockit.Injectable;
import mockit.NonStrictExpectations;
import mockit.Tested;
import mockit.integration.junit4.JMockit;
import org.junit.Test;
import org.junit.runner.RunWith;
import java.util.List;
import static java.util.Arrays.asList;
import static org.hamcrest.core.Is.is;
import static org.junit.Assert.assertThat; @RunWith(JMockit.class)
public class RecipientServiceTest { @Tested
private RecipientService recipientService; @Injectable
private RecipientRepository recipientRepository; @Test
public void should_return_success_when_add_recipient_not_exist() throws Exception {
Result result = recipientService.add("Tom", "test@test.com");
assertThat(result.getStatus(), is("成功"));
}
}

相对Controller Test这里少了一步对recipientRepository对象findByEmail方法的mock,因为如果不通过Expectations进行方法mock的话,方法会默认返回null,而我们要测试的场景正是需要findByEmail方法返回null,所以mock方法这一步我们也省了。改写后的整体代码也比原来的少了很多,而且速度更快。

7、Mock使用建议

JMockit功能非常强大,不仅可以轻松处理上面的这些测试场景,还可以对static,final,private等方法进行mock,可以让你的单元测试毫无阻碍的进行。
但是如果过度的使用Mock框架,会让功能代码的真正问题被掩盖。本来单元测试的设计可以让你发现功能代码上的一些设计是否合理,比如有没有紧耦合等,但使用JMockit可以让你在设计不合理的代码上也可以轻松地进行单元测试,这样你就很难发现功能代码上的问题了。
所以建议JMockit等类似的mock框架还是要谨慎使用,首先要保证功能代码设计合理,满足面向对象设计的要求,再来考虑提高单元测试效率的问题。

另外,Mock的函数是不计算到单元测试覆盖率里边的,如下图所示:

注意:我们mock了hello方法,但是在EclEmma中显示覆盖率为0%。

8、重要:注意事项以及调试中遇到的问题

问题1 编译报错方法名无法找到

在pom.xml文件中,注意依赖次序,JMockit一定要在JUnit之前,否则容易出现编译报错方法名找不到之类的奇葩问题:

问题2 报错Jmockit初始化异常

引用的版本必须保持一致,可以在build path里查看是否是自己用的版本,否则会报错Jmockit初始化异常:

问题3 版本造成java.lang.NoSuchMethodError

Junit使用最新版本是4.12。系统默认的junit版本太低了。会报异常如下:

java.lang.NoSuchMethodError: org.junit.runner.Request.classWithoutSuiteMethod(Ljava/lang/Class;)Lorg/junit/runner/Request;
at org.eclipse.jdt.internal.junit4.runner.JUnit4TestLoader.createFilteredTest(JUnit4TestLoader.java:76)
at org.eclipse.jdt.internal.

改为最新版本,Junit运行正常:

<!-- https://mvnrepository.com/artifact/junit/junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>

问题4 报错cannot be resolved to a type

调试过程中报错:

xxx cannot be resolved to a type

解决方法,在发生错误的项目上单击鼠标右键-〉Properties,选中“Resource”,右侧Text file encoding选择“Other:UTF-8”,点击“Apply”按钮。

附录:参考文档一览

JMockit官网:http://jmockit.org/

使用JMockit编写java单元测试: http://blog.csdn.net/chjttony/article/details/17838693

感谢阅读,作者原创技术文章,转载请注明出处

看完点个赞呗,难道想白嫖不成?更多内容请访问微信公众号 :三国测,扫码关注哟!

其他推荐相关阅读:

单元测试系列之一:如何使用JUnit、JaCoCo和EclEmma提高单元测试覆盖率

测试系列之二:Mock工具Jmockit实战

单元测试系列之三:JUnit单元测试规范

单元测试系列之四:Sonar平台中项目主要指标以及代码坏味道详解

单元测试系列之五:Mock工具之Mockito实战

单元测试系列之六:JUnit5 技术前瞻

单元测试系列之七:Sonar 数据库表关系整理一(rule相关)

单元测试系列之八:Sonar 数据库表关系整理一(续)

单元测试系列之九:Sonar 常用代码规则整理(一)

单元测试系列之十:Sonar 常用代码规则整理(二)

单元测试系列之十一:Jmockit之mock特性详解

单元测试系列:Mock工具Jmockit使用介绍的更多相关文章

  1. 单元测试系列之二:Mock工具Jmockit实战

    更多原创测试技术文章同步更新到微信公众号 :三国测,敬请扫码关注个人的微信号,感谢! 原文链接:http://www.cnblogs.com/zishi/p/6760272.html Mock工具Jm ...

  2. 单元测试系列:JUnit单元测试规范

    更多原创测试技术文章同步更新到微信公众号 :三国测,敬请扫码关注个人的微信号,感谢! 原文链接:http://www.cnblogs.com/zishi/p/6762032.html Junit测试代 ...

  3. 单元测试系列:如何使用JUnit+JaCoCo+EclEmma完成单元测试

    更多原创测试技术文章同步更新到微信公众号 :三国测,敬请扫码关注个人的微信号,感谢!   原文链接:http://www.cnblogs.com/zishi/p/6726664.html -----如 ...

  4. 单元测试系列:Mock工具之Mockito实战

    更多原创测试技术文章同步更新到微信公众号 :三国测,敬请扫码关注个人的微信号,感谢! 原文链接:http://www.cnblogs.com/zishi/p/6780719.html 在实际项目中写单 ...

  5. 单元测试系列之五:Mock工具之Mockito实战

    更多原创测试技术文章同步更新到微信公众号 :三国测,敬请扫码关注个人的微信号,感谢! 原文链接:http://www.cnblogs.com/zishi/p/6780719.html 在实际项目中写单 ...

  6. 单元测试系列之十一:Jmockit之mock特性详解

    本文是Jmockit学习过程中,根据官网所列的工具特性进行解读. 1.调用次数约束(Invocation count constraints) 可以通过调用计数约束来指定预期和/或允许匹配给定期望的调 ...

  7. 单元测试系列之一:如何使用JUnit、JaCoCo和EclEmma提高单元测试覆盖率

    更多原创测试技术文章同步更新到微信公众号 :三国测,敬请扫码关注个人的微信号,感谢!   原文链接:http://www.cnblogs.com/zishi/p/6726664.html -----如 ...

  8. 单元测试系列之四:Sonar平台中项目主要指标以及代码坏味道详解

    更多原创测试技术文章同步更新到微信公众号 :三国测,敬请扫码关注个人的微信号,感谢! 原文链接:http://www.cnblogs.com/zishi/p/6766994.html 众所周知Sona ...

  9. 单元测试系列之十:Sonar 常用代码规则整理(二)

    摘要:帮助公司部署了一套sonar平台,经过一段时间运行,发现有一些问题出现频率很高,因此有必要将这些问题进行整理总结和分析,避免再次出现类似问题. 作者原创技术文章,转载请注明出处 ======== ...

随机推荐

  1. js时间戳与日期格式的相互转换

    下面总结一下js中时间戳与日期格式的相互转换: 1. 将时间戳转换成日期格式: function timestampToTime(timestamp) { var date = new Date(ti ...

  2. HDU 5144 NPY and shot(物理运动学+三分查找)

    NPY and shot Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Tot ...

  3. bzoj:3398 [Usaco2009 Feb]Bullcow 牡牛和牝牛

    Description     约翰要带N(1≤N≤100000)只牛去参加集会里的展示活动,这些牛可以是牡牛,也可以是牝牛.牛们要站成一排.但是牡牛是好斗的,为了避免牡牛闹出乱子,约翰决定任意两只牡 ...

  4. UVALive3882-And Then There Was One-约瑟夫问题-递推

    And Then There Was One Time limit: 3.000 seconds Let's play a stone removing game. Initially, n ston ...

  5. hdu_1251统计难题(字典树Trie)

    统计难题 Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 131070/65535 K (Java/Others)Total Submi ...

  6. Trees on the level(指针法和非指针法构造二叉树)

    Trees on the level Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Other ...

  7. LockSupport理解

    一.背景 在看并发包源码的时候看见过LockSupport,今天恰巧看到LockSupport字眼,于是看下jdk1.7中的源码结构.想着它应该是运用多线程的锁工具的,到底似乎怎么实现的呢? 二.使用 ...

  8. light oj 1184 Marriage Media

    题目: You run a marriage media. You take some profiles for men and women, and your task is to arrange ...

  9. Flume环境搭建_五种案例

    Flume环境搭建_五种案例 http://flume.apache.org/FlumeUserGuide.html A simple example Here, we give an example ...

  10. Kafka集群的搭建

    Kafka集群的搭建 node1   node2   node3 kafka须用版本(kafka-0.8.2.2),否则不兼容spark1.6 1.启动zookeeper集群node1   node2 ...