mock测试框架Mockito

无论是敏捷开发、持续交付，还是测试驱动开发（TDD）都把单元测试作为实现的基石。随着这些先进的编程开发模式日益深入人心，单元测试如今显得越来越重要了。在敏捷开发、持续交付中要求单元测试一定要快（不能访问实际的文件系统或数据库），而TDD经常会碰到协同模块尚未开发的情况，而mock技术正是解决这些问题的灵丹妙药。

mock技术的目的和作用是模拟一些在应用中不容易构造或者比较复杂的对象，从而把测试与测试边界以外的对象隔离开。

我们可以自己编写自定义的Mock对象实现mock技术，但是编写自定义的Mock对象需要额外的编码工作，同时也可能引入错误。现在实现mock技术的优秀开源框架有很多，本文对几个典型的mock测试框架作了简明介绍，希望对大家有所帮助。

1.EasyMock

EasyMock 是早期比较流行的MocK测试框架。它提供对接口的模拟，能够通过录制、回放、检查三步来完成大体的测试过程，可以验证方法的调用种类、次数、顺序，可以令 Mock 对象返回指定的值或抛出指定异常。通过 EasyMock，我们可以方便的构造 Mock 对象从而使单元测试顺利进行。

EasyMock 是采用 MIT license 的一个开源项目，可以在 Sourceforge 上下载到。(http://sourceforge.net/projects/easymock/files/EasyMock/)

如果使用maven也可以如下引入：

<dependency>
  <groupId>org.easymock</groupId>
  <artifactId>easymock</artifactId>
  <version>3.1</version>
  <scope>test</scope>
</dependency>

使用EasyMock大致可以划分为以下几个步骤：

①    使用 EasyMock 生成 Mock 对象；

②    录制 Mock 对象的预期行为和输出；

③    将 Mock 对象切换到 播放 状态；

④    调用 Mock 对象方法进行单元测试；

⑤    对 Mock 对象的行为进行验证。

现在用一个例子来简单呈现以上的步骤，假设有一个类需要被模拟的类如下：

public class Class1Mocked {
         public  String hello(String name){
                   System.out.println("hello "+name);
                   return "hello "+name;
         }
         public void show(){
                   System.out.println("Class1Mocked.show()");
         }
}

　　首先静态导入EasyMock的方法：

import static org.easymock.EasyMock.*;

例1.1 EasyMock第一个例子

@Test
public void testMockMethod() {
         Class1Mocked obj = createMock(Class1Mocked.class);①

         expect(obj.hello("z3")).andReturn("hello l4");②
         replay(obj);③

         String actual = obj.hello("z3");④
         assertEquals("hello l4", actual);

         verify(obj);⑤
}

在⑤验证阶段中，会严格验证mock对象是否按录制的行为如期发生(包括执行的顺序及次数)。

2.mockito

EasyMock之后流行的mock工具。相对EasyMock学习成本低，而且具有非常简洁的API，测试代码的可读性很高。

mockito可以在https://code.google.com/p/mockito/上下载，如果使用maven可以如下引入：

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

使用mockito大致可以划分为以下几个步骤：

①    使用 mockito 生成 Mock 对象；

②    定义(并非录制) Mock 对象的行为和输出(expectations部分)；

③    调用 Mock 对象方法进行单元测试；

④    对 Mock 对象的行为进行验证。

现在用一个例子来简单呈现以上的步骤：

　　首先静态导入mockito的方法：

import static org.mockito.Mockito.*;

例2.1 mockito第一个例子

@Test
public void testMockMethod() {
    Class1Mocked obj=mock(Class1Mocked.class);①

    when(obj.hello("z3")).thenReturn("hello l4");②

    String actual=obj.hello("z3");③
    assertEquals("hello l4",actual);

    verify(obj).hello("z3");④
    //verify(obj,times(1)).hello("z3"); //可以加参数验证次数
}

可以看到与EasyMock相比，少了切换到播放状态一步。这是很自然的，本来就不是录制而谈播放呢，而在验证阶段可以通过增加参数(time(int)、atLeastOnce()、atLeast(int)、never()等)来精确验证调用次数。

而如果要验证调用顺序可以如下控制：

例2.2 验证顺序

@Test
public void testMockMethodInOrder() {
    Class1Mocked objOther = mock(Class1Mocked.class);
    Class1Mocked objCn = mock(Class1Mocked.class);

    when(objOther.hello("z3")).thenReturn("hello l4");
    when(objCn.hello("z3")).thenReturn("hello 张三");

    String other = objOther.hello("z3");
    assertEquals("hello l4", other);
    String cn = objCn.hello("z3");
    assertEquals("hello 张三", cn);

    InOrder inOrder = inOrder(objOther, objCn); //此行并不决定顺序，下面的两行才开始验证顺序
    inOrder.verify(objOther).hello("z3");
    inOrder.verify(objCn).hello("z3");
}

在之前的介绍的模拟操作中，我们总是去模拟一整个类或者对象，对于没有使用 When().thenReturn()方法指定的函数，系统会返回各种类型的默认值（具体值可参考官方文档）。而局部模拟创建出来的模拟对象依然是原系统对象，虽然可以使用方法When().thenReturn()来指定某些具体方法的返回值，但是没有被用此函数修改过的函数依然按照系统原始类的方式来执行，下面对非局部模拟和局部模拟分别举例来说明:

例2.3 非局部模拟

@Test
public void testSkipExpect() {
    Class1Mocked obj = mock(Class1Mocked.class);

    assertEquals(null, obj.hello("z3"));
    obj.show();

    verify(obj).hello("z3");
    verify(obj).show();
}

上面的代码省略了expectations部分(即定义代码行为和输出)，运行该测试可以看到hello方法默认返回null(show方法本来就是无返回值的)，而且在控制台中两个方法都没有输出任何语句。

mockito的局部模拟有两种方式，一种是doCallRealMethod()方式，另一种是spy()方式。

例2.4 局部模拟doCallRealMethod ()方式

@Test
public void testCallRealMethod () {
    Class1Mocked obj = mock(Class1Mocked.class);

    doCallRealMethod().when(obj).hello("z3"); 

    assertEquals("hello z3",obj.hello("z3"));
    assertEquals(null,obj.hello("l4"));
    obj.show();

    verify(obj).hello("z3");
    verify(obj).hello("l4");
    verify(obj).show();
}

运行这个测试会发现在执行hello("z3")时会执行原有的代码，而执行hello("l4")时则是返回默认值null且没有输出打印，执行show()同样没有输出打印。

例2.5 局部模拟spy()方式

@Test
public void testSpy() {
    Class1Mocked obj = spy(new Class1Mocked());

    doNothing().when(obj).show();

    assertEquals("hello z3",obj.hello("z3"));
    obj.show();

    verify(obj).hello("z3");
    verify(obj).show();
}

运行这个测试会发现在执行hello("z3")时会执行原有的代码，但是执行show()时在控制台中没有打印语句。

但值得注意的是在mockito的psy()方式模拟中expectations部分使用的语法不同，执行起来存在微妙的不同，如下：

例2.6 值得注意的“陷阱”

@Test
public void testSpy2() {
    Class1Mocked obj = spy(new Class1Mocked());

    when(obj.hello("z3")).thenReturn("hello l4");

    assertEquals("hello l4",obj.hello("z3"));

    verify(obj).hello("z3");
}

上面的代码虽然能顺利运行，但在控制台中输出了hello z3，说明实际的代码仍然执行了，只是mockito在最后替换了返回值。但下面的代码就不会执行实际的代码：

@Test
public void testSpy3() {
    Class1Mocked obj = spy(new Class1Mocked());

    doReturn("hello l4").when(obj).hello("z3");

    assertEquals("hello l4",obj.hello("z3"));

    verify(obj).hello("z3");
}

3.PowerMock

这个工具是在EasyMock和Mockito上扩展出来的，目的是为了解决EasyMock和Mockito不能解决的问题，比如对static, final, private方法均不能mock。其实测试架构设计良好的代码，一般并不需要这些功能，但如果是在已有项目上增加单元测试，老代码有问题且不能改时，就不得不使用这些功能了。

PowerMock 在扩展功能时完全采用和被扩展的框架相同的 API, 熟悉 PowerMock 所支持的模拟框架的开发者会发现 PowerMock 非常容易上手。PowerMock 的目的就是在当前已经被大家所熟悉的接口上通过添加极少的方法和注释来实现额外的功能。目前PowerMock 仅扩展了 EasyMock 和 mockito，需要和EasyMock或Mockito配合一起使用。

PowerMock可以在https://code.google.com/p/powermock/上下载，本文以PowerMock+mockito为例,使用maven的话，添加如下依赖即可，maven会自动引入mockito的包。

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

现在举例来说明PowerMock的使用，假设有一个类需要被模拟的类如下：

public class Class2Mocked {
    public static int getDouble(int i){
        return i*2;
    }
    public String getTripleString(int i){
        return multiply3(i)+"";
    }
    private int multiply3(int i){
        return i*3;
    }
}

首先静态导入PowerMock的方法：

import static org.powermock.api.mockito.PowerMockito.*;

然后在使用junit4的测试类上做如下声明：

@RunWith(PowerMockRunner.class)
@PrepareForTest( { Class2Mocked.class })

例3.1 模拟静态方法

@Test
public void testMockStaticMethod() {
    mockStatic(Class2Mocked.class);
    when(Class2Mocked.getDouble(1)).thenReturn(3);

    int actual = Class2Mocked.getDouble(1);
    assertEquals(3, actual);

    verifyStatic();
    Class2Mocked.getDouble(1);
}

PowerMockit的局域模拟使用方式和mockito类似(毕竟是扩展mockito),但强大之处在于可以模拟private方法，普通方法和final方法。模拟普通方法和final方法的方式与模拟private方法一模一样，现以模拟private方法为例。

例3.2 模拟私有方法(doCallRealMethod方式)

@Test
public void testMockPrivateMethod() throws Exception {
    Class2Mocked obj = mock(Class2Mocked.class);

    when(obj, "multiply3", 1).thenReturn(4);
    doCallRealMethod().when(obj).getTripleString(1);

    String actual = obj.getTripleString(1);
    assertEquals("4", actual);

    verifyPrivate(obj).invoke("multiply3", 1);
}

例3.3 模拟私有方法(spy方式)

@Test
public void testMockPrivateMethod2() throws Exception {
    Class2Mocked obj = spy(new Class2Mocked());
    when(obj, "multiply3", 1).thenReturn(4);

    String actual = obj.getTripleString(1);
    assertEquals("4", actual);

    verifyPrivate(obj).invoke("multiply3", 1);
}

除此之外，PowerMock也可以模拟构造方法,如下所示：

例3.4 模拟构造方法

@Test
public void testStructureWhenPathDoesntExist() throws Exception {
    final String directoryPath = "mocked path"; 

    File directoryMock = mock(File.class); 

    whenNew(File.class).withArguments(directoryPath).thenReturn(directoryMock);
    when(directoryMock.exists()).thenReturn(true); 

    File file=new File(directoryPath);
    assertTrue(file.exists()); 

    verifyNew(File.class).withArguments(directoryPath);
    verifyPrivate(directoryMock).invoke("exists");
}

4.Jmockit

JMockit 是一个轻量级的mock框架是用以帮助开发人员编写测试程序的一组工具和API，该项目完全基于 Java 5 SE 的 java.lang.instrument 包开发，内部使用 ASM 库来修改Java的Bytecode。

Jmockit功能和PowerMock类似，某些功能甚至更为强大，但个人感觉其代码的可读性并不强。

Jmockit可以在https://code.google.com/p/jmockit/上下载，使用maven的话添加如下依赖即可：

<dependency>
  <groupId>com.googlecode.jmockit</groupId>
  <artifactId>jmockit</artifactId>
  <version>1.0</version>
  <scope>test</scope>
</dependency>

Jmockit也可以分类为非局部模拟与局部模拟，区分在于Expectations块是否有参数，有参数的是局部模拟，反之是非局部模拟。而Expectations块一般由Expectations类和NonStrictExpectations类定义。用Expectations类定义的，则mock对象在运行时只能按照 Expectations块中定义的顺序依次调用方法，不能多调用也不能少调用，所以可以省略掉Verifications块；而用NonStrictExpectations类定义的，则没有这些限制，所以如果需要验证，则要添加Verifications块。

现在举例说明Jmockit的用法：

例4.1 非局部模拟Expectations类定义

@Mocked  //用@Mocked标注的对象，不需要赋值，jmockit自动mock
Class1Mocked obj;

@Test
public void testMockNormalMethod1() {
    new Expectations() {
        {
            obj.hello("z3");
            returns("hello l4", "hello w5");
            obj.hello("张三");
            result="hello 李四";
        }
    };

    assertEquals("hello l4", obj.hello("z3"));
    assertEquals("hello w5", obj.hello("z3"));
    assertEquals("hello 李四", obj.hello("张三"));

    try {
        obj.hello("z3");
    } catch (Throwable e) {
        System.out.println("第三次调用hello(\"z3\")会抛出异常");
    }
    try {
        obj.show();
    } catch (Throwable e) {
        System.out.println("调用没有在Expectations块中定义的方法show()会抛出异常");
    }
}

例4.2 非局部模拟 NonStrictExpectations类定义

public void testMockNormalMethod2() {
    new NonStrictExpectations() {
        {
            obj.hello("z3");
            returns("hello l4", "hello w5");
        }
    };

    assertEquals("hello l4", obj.hello("z3"));
    assertEquals("hello w5", obj.hello("z3"));
    assertEquals("hello w5", obj.hello("z3"));// 会返回在NonStrictExpectations块中定义的最后一个返回值
    obj.show();

    new Verifications() {
        {
            obj.hello("z3");
            times = 3;
            obj.show();
            times = 1;
        }
    };
}

运行这个测试会发现show()方法没有在控制台输出打印语句，说明是Jmockit对show方法也进行了默认mock。

例4.3 局部模拟

@Test
public void testMockNormalMethod() throws IOException {
    final Class1Mocked obj = new Class1Mocked();//也可以不用@Mocked标注，但需要final关键字
    new NonStrictExpectations(obj) {
        {
            obj.hello("z3");
            result = "hello l4";
        }
    };

    assertEquals("hello l4", obj.hello("z3"));
    assertEquals("hello 张三", obj.hello("张三"));

    new Verifications() {
        {
            obj.hello("z3");
            times = 1;
            obj.hello("张三");
            times = 1;
        }
    };
}

运行这个测试发现hello("z3")返回由Expectations块定义的值，但hello("张三")执行的是实际的代码。

例4.4 模拟静态方法

@Test
public void testMockStaticMethod() {
    new NonStrictExpectations(Class2Mocked.class) {
        {
            Class2Mocked.getDouble(1);
            result = 3;
        }
    };

    assertEquals(3, Class2Mocked.getDouble(1));

    new Verifications() {
        {
            Class2Mocked.getDouble(1);
            times = 1;
        }
    };
}

例4.5 模拟私有方法

@Test
public void testMockPrivateMethod() throws Exception {
    final Class2Mocked obj = new Class2Mocked();
    new NonStrictExpectations(obj) {
        {
            this.invoke(obj, "multiply3", 1);
            result = 4;
        }
    };

    String actual = obj.getTripleString(1);
    assertEquals("4", actual);

    new Verifications() {
        {
            this.invoke(obj, "multiply3", 1);
            times = 1;
        }
    };
}

例4.6 设置私有属性的值

假设有一个类需要被模拟的类如下：

public class Class3Mocked {
    private String name = "name_init";

    public String getName() {
        return name;
    }

    private static String className="Class3Mocked_init";

    public static String getClassName(){
        return className;
    }

    public static int getDouble(int i){
        return i*2;
    }

    public int getTriple(int i){
        return i*3;
    }
}

如下可以设置私有属性的值：

@Test
public void testMockPrivateProperty() throws IOException {
    final Class3Mocked obj = new Class3Mocked();
    new NonStrictExpectations(obj) {
        {
            this.setField(obj, "name", "name has bean change!");
        }
    };

    assertEquals("name has bean change!", obj.getName());
}

例4.7 设置静态私有属性的值

@Test
public void testMockPrivateStaticProperty() throws IOException {
    new NonStrictExpectations(Class3Mocked.class) {
        {
            this.setField(Class3Mocked.class, "className", "className has bean change!");
        }
    };

    assertEquals("className has bean change!", Class3Mocked.getClassName());
}

例4.8 改写普通方法的内容

@Test
public void testMockNormalMethodContent() throws IOException {
    final Class3Mocked obj = new Class3Mocked();
    new NonStrictExpectations(obj) {
        {
            new MockUp<Class3Mocked>() {
                @Mock
                public int getTriple(int i) {
                    return i * 30;
                }
            };
        }
    };

    assertEquals(30, obj.getTriple(1));
    assertEquals(60, obj.getTriple(2));
}

例4.9 改写静态方法的内容

如果要改写Class3Mocked类的静态getDouble方法，则需要新建一个类含有与getDouble方法相同的函数声明，并且用@Mock标注，如下：

public class Class4Mocked {
    @Mock
    public static int getDouble(int i){
        return i*20;
    }
}

如下即可改写：

@Test
public void testDynamicMockStaticMethodContent() throws IOException {
    Mockit.setUpMock(Class3Mocked.class, Class4Mocked.class);

    assertEquals(20, Class3Mocked.getDouble(1));
    assertEquals(40, Class3Mocked.getDouble(2));
}

时间： 2024-10-26 06:02:46

mock测试框架Mockito的相关文章

Mock测试框架(Mockito为例)

在做单元测试的时候,有的时候用到的一些类,我们构造起来不是那么容易,比如HttpRequest,或者说某个Service依赖到了某个Dao,想构造service还得先构造dao,这些外部对象构造起来比较麻烦. 所以出现了Mock! 我们可以用 Mock 工具来模拟这些外部对象,来完成我们的单元测试. 实现Mock技术的优秀开源框架有很多,下面以Mockito为例,用几个简单例子来介绍Mock工具的基本使用: 1.Mockito的第一个示例 1 @Test 2 public void simple

java的mock测试框架

无论是敏捷开发.持续交付,还是测试驱动开发(TDD)都把单元测试作为实现的基石.随着这些先进的编程开发模式日益深入人心,单元测试如今显得越来越重要了.在敏捷开发.持续交付中要求单元测试一定要快(不能访问实际的文件系统或数据库),而TDD经常会碰到协同模块尚未开发的情况,而mock技术正是解决这些问题的灵丹妙药. mock技术的目的和作用是模拟一些在应用中不容易构造或者比较复杂的对象,从而把测试与测试边界以外的对象隔离开. 我们可以自己编写自定义的Mock对象实现mock技术,但是编写自定义的Mo

Mock测试框架

一.前言 使用Mock框架进行单元测试,能够使用当前系统已经开发的接口方法模拟数据.(未写完,慢慢完善) 二.例子 1.引用Moq 2.定义一个接口和方法作为测试 public interface IAnimal { //创造动物,返回是否创造成功 bool CreateAnimal(string name); //方法参数中有输出参数 bool AnimalDance(string name, out string msg); string Eat(string food); int GetC

【翻译】Java使用Mockito进行Mock测试

我们所有人在编写单元测试的时候面临的巨大挑战是模块对其他组件的依赖.同时花费大量的时间和精力去配置依赖的组件环境是一件出力不讨好的事情.使用Mock是一种有效地方式替代其他组件用来继续我们的单元测试构建过程. 接下来我将会展示一个使用mock技术的实例.这里我有一个数据访问层(简称DAL),建立一个类,提供应用程序访问和修改数据库中数据的基本API.接着我会测试这个DAL实例,但并不真正连接数据库.使用DAL类的目的是帮助我们隔离应用程序代码和数据显示层. 让我们通过下面的命令行创建一个java

使用强大的 Mockito 测试框架来测试你的代码

原文链接 : Unit tests with Mockito - Tutorial 译文出自 : 掘金翻译计划 译者 : edvardhua 校对者: hackerkevin, futureshine 这篇教程介绍了如何使用 Mockito 框架来给软件写测试用例 1. 预备知识 如果需要往下学习,你需要先理解 Junit 框架中的单元测试. 如果你不熟悉 JUnit,请查看下面的教程: www.vogella.com/tutorials/J- 2. 使用mock对象来进行测试 2.1. 单元测

强大的Mockito测试框架（转）

1.自动生成Mock类在需要Mock的属性上标记@Mock注解,然后@RunWith中配置Mockito的TestRunner或者在setUp()方法中显示调用MockitoAnnotations.initMocks(this);生成Mock类即可. 2.自动注入Mock类到被测试类只要在被测试类上标记@InjectMocks,Mockito就会自动将标记@Mock.@Spy等注解的属性值注入到被测试类中 import static org.mockito.Mockito.when; impor

Mockito－部分mock测试使用

什么是类的部分mock(partial mock)?A:部分mock是说一个类的方法有些是实际调用,有些是使用mockito的stubbing(桩实现). 为什么需要部分mock? A:当需要测试一个组合方法(一个方法需要其它多个方法协作)的时候,某个叶子方法(只供别人调用,自己不依赖其它反复)已经被测试过,我们其实不需要再次测试这个叶子方法,so,让叶子打桩实现返回结果,上层方法实际调用并测试. mockito实现部分mock的两种方式:spy和callRealMethod() spy实现:

测试驱动开发神器框架Mockito

作为菜鸟的我,以前没接触过Mock类型的框架,比如说要测试action层,我总是从action层调用service再调用dao访问数据库,这种方式从原则上来说是无疑是非常正确的,在没用mock框架之前我就隐隐约约的感觉到了这种方式有个不足的地方,那就是速度问题,测试action层的时候需要访问下面两层,如果我们下面两层已经经过单元测试证明是ok的,那么如果测试action层的时候再调用下面两层就等于是做了重复的动作,逻辑上没问题,只是有点重复,并且速度很慢,毕竟项目做到靠后期的时候文单元测试非常

Android开源测试框架学习

近期因工作需要,分析了一些Android的测试框架,在这也分享下整理完的资料. Android测试大致分三大块: 代码层测试 用户操作模拟,功能测试 安装部署及稳定性测试 代码层测试 对于一般java代码,采用传统的Junit测试,开发人员通常会编写重要接口和函数的白盒测试代码,不做过多讨论. 但因Android的特殊运行机制(Dalvik虚拟机),其中存在Application.Activity.Service等特殊组件,而这些组件都涉及到生命周期管理的问题. 为了对这些组件进行测试,Goog