Mockito简介(转)

 

Mockito 是目前 java 单测中使用比较流行的 mock 工具。其他还有 EasyMock,JMock,MockCreator,Mockrunner,MockMaker 及 PowerMock。

项目地址:https://code.google.com/p/mockito/

powermock 简介

EasyMock 以及 Mockito 都因为可以极大地简化单元测试的书写过程而被许多人应用在自己的工作中,但是这两种 Mock 工具都不可以实现对静态函数、构造函数、私有函数、Final 函数以及系统函数的模拟,但是这些方法往往是我们在大型系统中需要的功能。PowerMock 是在 EasyMock 以及 Mockito 基础上的扩展,通过定制类加载器等技术,PowerMock 实现了之前提到的所有模拟功能,使其成为大型系统上单元测试中的必备工具。缺点是缺少文档。

项目地址:https://code.google.com/p/powermock/

Mock 和Stub

Mock

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

Stub

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

Stub 与 Mock 的区别

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

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方法。

Maven 程序

1.模拟对象

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

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

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

3.验证被测试类方法

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

Demo

Mock 对象的创建

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

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

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

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

LinkedList mockedList = mock(LinkedList.class);

对方法进行设定返回值和异常

对包含返回值的方法的设定

when(mockedList.get(0)).thenReturn("first");
when(mockedList.get(1)).thenThrow(new RuntimeException());

Mockito支持迭代风格的返回值设定

when(mockedList.get(anyInt()).thenReturn("first").thenThrow(new RuntimeException());
when(mockedList.get(anyInt()).thenReturn("first","second");

Stubbing的另一种风格

doReturn("Hello").when(mockedList).get(0);
doReturn("Hello").doReturn("world").when(mockedList).get(anyInt());

抛出异常

doThrow(new RuntimeException()).when(mockedList).get(0);

对void方法进行方法预期设定

doNothing().when(mockedClass).SomeVoidMethod();
doThrow(new RuntimeException()).when(mockedClass).SomeVoidMethod();

迭代风格

doNothing().doThrow(new RuntimeException()).when(mockedClass).SomeVoidMethod();

参数匹配器

在Stubbing和Verify的时候,有时需要更加灵活的参数需求。参数匹配器(Argument Matcher)能够满足需求。

//stubbing using anyInt() argument matcher
when(mockedList.get(anyInt())).thenReturn("element");

//following prints "element"
System.out.println(mockedList.get(999));

//you can also verify using argument matcher
verify(mockedList).get(anyInt());

需要注意的是,如果使用了参数匹配器,所有的参数都需要由匹配器提供。如下eq(“third argument”),直接修改为“third argument”会报错。

verify(mockedClass).someMethod(anyObject(), anyString(), eq("third argument"));

Mock对象行为的验证

Mock 对象行为的验证,关注其交互行为,如mock对象调用的参数,调用次数,调用顺序等。

调用次数验证

public static <T> T verify(T mock).someMethod()
public static <T> T verify(T mock, VerificationMode mode).someMethod()

Parameters:
    mock - to be verified
    mode - times(M), atLeastOnce() , atLeast(N) , atMost(X) , never()
Returns:
    mock object itself

调用顺序验证

public static InOrder inOrder(java.lang.Object... mocks)

创建mock对象

// Multiple mocks that must be used in a particular order
List firstMock = mock(List.class);
List secondMock = mock(List.class);

调用mock对象的方法

//using mocks
firstMock.add("was called first");
secondMock.add("was called second");

创建InOrder对象

//create inOrder object passing any mocks that need to be verified in order
InOrder inOrder = inOrder(firstMock, secondMock);

验证方法调用

//following will make sure that firstMock was called before secondMock
inOrder.verify(firstMock).add("was called first");
inOrder.verify(secondMock).add("was called second");

RETURN_SMART_NULLS和RETURN_DEEP_STUBS

RETURN_SMART_NULLS 是实现了Answer 接口的对象,它是创建mock对象时的一个可选参数, mock(class,answer)。在创建mock对象时,使用该参数,调用没有stubbed的方法会返回 SmartNull 。如返回类型为String的,会返回空”“, int 会返回 0,List 会返回 null。

mock对象使用RETURN_DEEP_STUBS 参数,会自动mock该对象中包含的对象。

注解

Mockito支持对变量进行注解,如将mock对象设为测试类的属性,然后通过注解的方式@Mock来定义它,可以减少重复代码,增强可维护性。Mockito支持的注解有@Mock,@Spy,@Captor,@InjectMocks

Annotation 的初始化

初始化方法为调用MockitoAnnotations.initMocks(testClass),可以放到@Before中。

public class ArticleManagerTest {

    @Mock private ArticleCalculator calculator;
    @Mock private ArticleDatabase database;
    @Mock private UserProvider userProvider;

    @Before public void setup() {
        MockitoAnnotations.initMocks(testClass);
    }
}

使用Mockito提供的Junit Runner可以省略上述步骤。

@RunWith(MockitoJUnitRunner.class)
public class ExampleTest {
    @Mock private List list;

    @Test public void shouldDoSomething() {
        list.add(100);
    }
}

powermock 的使用

Maven配置

<dependency>
    <groupId>org.powermock</groupId>
    <artifactId>powermock-module-junit4</artifactId>
    <version>1.4.10</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.powermock</groupId>
    <artifactId>powermock-api-mockito</artifactId>
    <version>1.4.10</version>
    <scope>test</scope>
</dependency>

PowerMock 在单元测试中的应用

模拟 Static 方法

在任何需要用到 PowerMock 的类开始之前,首先我们要做如下声明:

@RunWith(PowerMockRunner.class)

然后,还需要用注释的形式将需要测试的静态方法提供给 PowerMock:

@PrepareForTest( { YourClassWithEgStaticMethod.class })

然后就可以开始写测试代码:

1,首先,需要有一个含有 static 方法的代码 , 如
public class IdGenerator {
    ...
    public static long generateNewId() {
        ...
    }
    ...
 }
2,然后,在被测代码中,引用了以上方法
public class ClassUnderTest {
    ...
    public void methodToTest() {
    ..
    final long id = IdGenerator.generateNewId();
    ..
    }
    ...
} 

3,为了达到单元测试的目的,需要让静态方法 generateNewId()返回各种值
来达到对被测试方法 methodToTest()的覆盖测试,实现方式如下:

 @RunWith(PowerMockRunner.class)
 @PrepareForTest(IdGenerator.class)
 public class MyTestClass {
    @Test
    public void demoStaticMethodMocking() throws Exception {
        PowerMockito.mockStatic(IdGenerator.class);
        when(IdGenerator.generateNewId()).thenReturn(2L); 

        new ClassUnderTest().methodToTest(); 

        verifyStatic();
        IdGenerator.generateNewId();
    }
 }

模拟构造函数

有时候,能模拟构造函数,从而使被测代码中 new 操作返回的对象可以被随意定制,会很大程度的提高单元测试的效率,考虑如下:

public class DirectoryStructure {
    public boolean create(String directoryPath) {
        File directory = new File(directoryPath); 

        if (directory.exists()) {
            throw new IllegalArgumentException(
            "\"" + directoryPath + "\" already exists.");
        } 

        return directory.mkdirs();
    }
 }

为了充分测试 create()函数,我们需要被 new 出来的 File 对象返回文件存在和不存在两种结果。在 PowerMock 出现之前,实现这个单元测试的方式通常都会需要在实际的文件系统中去创建对应的路径以及文件。然而,在 PowerMock 的帮助下,本函数的测试可以和实际的文件系统彻底独立开来:使用 PowerMock 来模拟 File 类的构造函数,使其返回指定的模拟 File 对象而不是实际的 File 对象,然后只需要通过修改指定的模拟 File 对象的实现,即可实现对被测试代码的覆盖测试,参考如下:

 @RunWith(PowerMockRunner.class)
 @PrepareForTest(DirectoryStructure.class)
 public class DirectoryStructureTest {
    @Test
    public void createDirectoryStructureWhenPathDoesntExist()
    throws Exception {
        final String directoryPath = "mocked path"; 

        File directoryMock = mock(File.class); 

        //File的初始化函数的mock
        whenNew(File.class).withArguments(directoryPath)
            .thenReturn(directoryMock); 

        // Standard expectations
        when(directoryMock.exists()).thenReturn(false);
        when(directoryMock.mkdirs()).thenReturn(true); 

        assertTrue(new NewFileExample()
            .createDirectoryStructure(directoryPath)); 

        // Optionally verify that a new File was "created".
        verifyNew(File.class).withArguments(directoryPath);
    }
 }

使用 whenNew().withArguments().thenReturn() 语句即可实现对具体类的构造函数的模拟操作。然后对于之前创建的模拟对象 directoryMock使用 When().thenReturn() 语句,即可实现需要的所有功能,从而实现对被测对象的覆盖测试。在本测试中,因为实际的模拟操作是在类 DirectoryStructureTest 中实现,所以需要指定的 @PrepareForTest 对象是 DirectoryStructureTest.class。

模拟私有以及 Final 方法

为了实现对类的私有方法或者是 Final 方法的模拟操作,需要 PowerMock 提供的另外一项技术:局部模拟。

在之前的介绍的模拟操作中,我们总是去模拟一整个类或者对象,然后使用 When().thenReturn()语句去指定其中值得关心的部分函数的返回值,从而达到搭建各种测试环境的目标。对于没有使用 When().thenReturn()方法指定的函数,系统会返回各种类型的默认值。

局部模拟则提供了另外一种方式,在使用局部模拟时,被创建出来的模拟对象依然是原系统对象,虽然可以使用方法 When().thenReturn()来指定某些具体方法的返回值,但是没有被用此函数修改过的函数依然按照系统原始类的方式来执行。

这种局部模拟的方式的强大之处在于,除开一般方法可以使用之外,Final 方法和私有方法一样可以使用。 参考如下所示的被测代码:

 public final class PrivatePartialMockingExample {
    public String methodToTest() {
        return methodToMock("input");
    } 

    private String methodToMock(String input) {
        return "REAL VALUE = " + input;
    }
 }

为了保持单元测试的纯洁性,在测试方法 methodToTest()时,我们不希望受到私有函数 methodToMock()实现的干扰,为了达到这个目的,我们使用刚提到的局部模拟方法来实现 , 实现方式如下:

 @RunWith(PowerMockRunner.class)
 @PrepareForTest(PrivatePartialMockingExample.class)
 public class PrivatePartialMockingExampleTest {
    @Test
    public void demoPrivateMethodMocking() throws Exception {
        final String expected = "TEST VALUE";
        final String nameOfMethodToMock = "methodToMock";
        final String input = "input"; 

        PrivatePartialMockingExample underTest = spy(new PrivatePartialMockingExample()); 

        /*
         * Setup the expectation to the private method using the method name
         */
        when(underTest, nameOfMethodToMock, input).thenReturn(expected); 

        assertEquals(expected, underTest.methodToTest()); 

        // Optionally verify that the private method was actually called
        verifyPrivate(underTest).invoke(nameOfMethodToMock, input);
    }
 }

可以发现,为了实现局部模拟操作,用来创建模拟对象的函数从 mock() 变成了 spy(),操作对象也从类本身变成了一个具体的对象。同时,When() 函数也使用了不同的版本:在模拟私有方法或者是 Final 方法时,When() 函数需要依次指定模拟对象、被指定的函数名字以及针对该函数的输入参数列表。

参考文献:http://www.ibm.com/developerworks/cn/java/j-lo-powermock/

 

http://www.shenyanchao.cn/blog/2013/06/21/mockito-in-brief/

 

时间: 2024-10-05 03:25:20

Mockito简介(转)的相关文章

如何使用PowerMock以及Mockito实现单元测试

EasyMock 以及 Mockito 都因为可以极大地简化单元测试的书写过程而被许多人应用在自己的工作中,但是这 2 种 Mock 工具都不可以实现对静态函数.构造函数.私有函数.Final 函数以及系统函数的模拟,但是这些方法往往是我们在 大型系统中需要的功能.PowerMock 是在 EasyMock 以及 Mockito 基础上的扩展,通过定制类加载器等技术,PowerMock 实现了之前提到的所有模拟功能,使其成为大型系统上单元测试中的必备工具. 单元测试模拟框架的功能及其实现 简介

Android最佳Mock单元测试方案:Junit + Mockito + Powermock

本文旨在从实践出发,引导开发者在Android项目中进行Mock单元测试. 什么是单元测试 单元测试由一组独立的测试构成,每个测试针对软件中的一个单独的程序单元.单元测试并非检查程序单元之间是否能够合作良好,而是检查单个程序单元行为是否正确. 为什么要进行单元测试 在敏捷开发大行其道的今天,由于时间紧,任务重,过分依赖测试工程师以及下列原因,导致单元测试不被重视,在开发流程中处于一个可有可无的尴尬境地. 1. 浪费的时间太多 1. 软件开发人员不应参与单元测试 1. 我是很棒的程序员,不需要进行

mockito mock测试框架

1.简介 mock,[mɒk],adj. 虚拟的,模拟的. 如果你的代码对另一个类或者接口有依赖,mock测试能够帮你模拟这些依赖,从而完成测试. 使用场景: 类A有一个方法fun(B b),它依赖于B类的一个对象.所以要测试这个方法必须要有b对象.如果自己构造B对象,并做一些操作来适应测试,会显得麻烦.那么就可以用mock测试. 2.获得 mock测试是一种思想,mockito是一个实现框架. <dependency> <groupId>org.mockito</group

JUnit + Mockito 单元测试(一)

未接触 JUnit 之前,曾经对茫茫的代码不知所措--哪怕是自己写的--多写注释?重构代码?甚至为一个方法去写一篇技术文章来解释?--这些都是试过,感觉不是"控制代码"的可行之道,甚至说"徒劳"的.关于单元测试(Unit test),之前亦略有所闻,感觉用处不大,因为对一个方法检测返回的结果是否正确,--有点无聊--心想,我写的方法当然能返回预期的结果,这还有说?不至于那么低级的错误也犯得着吧!?于是对所谓测试的东东感觉简直就是在增加工作量--我把代码写漂亮点就行了

JUnit + Mockito 单元测试(三)

这里假设我们没有 Tomcat(虽然不太可能,假设吧!),那就使用 Mockito 模拟一个看看怎么样.本文结合 RESTful 接口来进行回归测试的目的. 模拟 ServletContextListener Listener 是启动 App 的第一个模块,相当于执行整个 Web 项目的初始化工作,所以也必须先模拟 ServletContextListener 对象.通过初始化的工作是安排好项目的相关配置工作和先缓存一些底层的类(作为 static 成员保存在内存中). package ajax

Python中title()方法的使用简介

  这篇文章主要介绍了Python中title()方法的使用简介,是Python入门中的基础知识,需要的朋友可以参考下 title()方法返回所有单词的第一个字符大写的字符串的一个副本. 语法 以下是title()方法的语法: ? 1 str.title(); 参数 NA 返回值 此方法返回其中所有单词的前几个字符都是大写的字符串的一个副本. 例子 下面的例子显示了title()方法的使用. ? 1 2 3 4 #!/usr/bin/python   str = "this is string

shiro(1)-简介

简介 apache shiro 是一个功能强大和易于使用的Java安全框架,为开发人员提供一个直观而全面的的解决方案的认证,授权,加密,会话管理. 在实际应用中,它实现了应用程序的安全管理的各个方面. shiro的功能 apache shiro能做什么? 支持认证跨一个或多个数据源(LDAP,JDBC,kerberos身份等) 执行授权,基于角色的细粒度的权限控制. 增强的缓存的支持. 支持web或者非web环境,可以在任何单点登录(SSO)或集群分布式会话中使用. 主要功能是:认证,授权,会话

Tutum公司简介

2015年10月21日,由Tutum公司的CEO Borja Burgos对外宣布,Tutum与Docker公司正式合作,大家对Tutum和Docker的合作还是很期待的.下面我简单介绍一下Tutum公司. Tutum的历史 Tutum创立的时间很难确定.Tutum(拉丁语里安全的意思)的最初构思是在2012年秋季,它是作为Borja Burgos在卡内基梅隆大学(匹兹堡)的研究生课程和在日本兵库县大学的硕士论文,Tutum是一个可以帮助企业过渡到云的安全支持系统. 在2013年初,Tutum有

在应用中加入全文检索功能——基于Java的全文索引引擎Lucene简介

全文检索|索引 内容摘要: Lucene是一个基于Java的全文索引工具包. 基于Java的全文索引引擎Lucene简介:关于作者和Lucene的历史 全文检索的实现:Luene全文索引和数据库索引的比较 中文切分词机制简介:基于词库和自动切分词算法的比较 具体的安装和使用简介:系统结构介绍和演示 Hacking Lucene:简化的查询分析器,删除的实现,定制的排序,应用接口的扩展 从Lucene我们还可以学到什么 基于Java的全文索引/检索引擎--Lucene Lucene不是一个完整的全