Mockito使用总结

Mockito使用总结

写UT时,经常会遇到执行过程中调用的方法返回结果不可控的情况,为了专注在某个确定范围内的开发自测,需要模拟这些方法和类的行为,Mockito提供了很好的解决方案。

使用Mockito可以很方便的设置、校验方法或类的行为,但是前提是首先创建一个mock对象,才能基于Mockito进行操作。

创建一个mock对象

可以简单的调用mock方法来创建一个mock对象:

List mockedList = Mockito.mock(List.class)
或者更简单地,可以直接用@mock:
@Mock
List mockedList;

如果要使用注解,必须打开注解开关:

MockitoAnnotations.initMocks(this);

设置mock对象的行为

我们可以设置mock对象调用某个方法的返回值:

Mockito.when(mockedList.get(0)).thenReturn("val");

或者设置调用方法时抛出某个异常:

Mockito.when(mockedList.get(1)).thenThrow(new RuntimeException());

对于一个mock对象,没有设置过的方法行为均返回null:

mockedList.get(999) // 将返回null

在实际使用中常常设置某个方法的返回值为另一个mock对象,在复杂的情况时可以以此来控制整个测试过程。

验证mock对象的行为

1、验证mock对象是否调用过某个方法:

Mockito.verify(mockedList).add("one");  // 是否执行过mockedList.add("one")

注意验证的目标对象必须是mock的,否则会报错。

2、验证方法调用了多少次、是否从未调用过:

Mockito.verify(mockedList, Mockito.times(2)).add("one");  // 是否调用过两次add("one")
Mockito.verify(mockedList, Mockito.never()).add("one");  // 是否从未调用过add("one")

3、验证某个mock对象是否从未使用过:

Mockito.verifyZeroInteractions(mockedList);

4、验证同一个mock对象执行不同方法的先后顺序:

List singleMock = Mockito.mock(List.class);
singleMock.add("first");
singleMock.add("second");
InOrder inOrder = Mockito.inOrder(singleMock);
// 验证调用顺序
inOrder.verify(singleMock).add("first");
inOrder.verify(singleMock).add("second");

5、验证不同mock对象执行不同方法的先后顺序:

List firstMock = Mockito.mock(List.class);
List secondMock = Mockito.mock(List.class);
firstMock.add("first");
secondMock.add("second");
InOrder inOrder = Mockito.inOrder(firstMock,secondMock);
// 验证调用顺序
inOrder.verify(firstMock).add("first");
inOrder.verify(secondMock).add("second");

匹配器

匹配器可以代替一类参数:

1、验证一类行为:

// 验证是否执行过mockedList的get方法,参数为任意int数
Mockito.verify(mockedList).get(Mock.anyInt()); 

2、设置一类行为:

// 当mockedList调用get方法,参数为任意int数,返回值都是element
Mockito.when(mockedList.get(Mockito.anyInt())).thenReturn("element");

部分模拟

1、部分模拟的概念

前面提到,如果某个对象被mock,那么它将不再拥有原本的功能,全部的方法都被替换掉了,只会返回设置好的值,如果mock对象的某个方法没有设置,那么就会返回null。当我们想要验证某个对象的行为,同时又需要它一部分功能保持不变时,就要使用部分模拟:

// 使用部分模拟需要用spy方法,它必须是某个已经建立好的对象的封装,不能用class对象为构造参数
List list = new LinkedList();
List mockedList = Mockito.spy(list);

后续我们可以正常调用它的方法,模拟它的部分行为,并验证它的功能:

// 设置method1方法的行为
Mockito.when(mockedList.method1(Mockito.anyInt())).thenReturn("element");

// 调用method2将正常返回原本该返回的值,走正常的方法流程,与mock无关
mockedList.method2();

// 验证对象的行为
Mockito.verify(mockedList).method1(Mock.anyInt()); 

2、不可模拟情况的替代方案

一旦对象是部分模拟的,在设置行为的过程中就可能发生异常,比如对于一个空集合mockedList,当执行下列语句时就会直接抛出越界异常:

Mockito.when(mockedList.get(0)).thenReturn("foo");

这种情况下应该用这种形式来模拟行为:

Mockito.doReturn("foo").when(mockedList).get(0);

3、使用mock来部分模拟

部分模拟也可以不用spy方法,使用mock一样可以完成相同的功能:

List mockedList = Mockito.mock(List.class);

// 调用某个方法时返回真实值
Mockito.when(mockedList.someMethod()).thenCallRealMethod();

 

4、注解的使用

和mock一样,spy方法也可以方便的用注解来代替,此时也要注意必须使用初始化后的对象,同时开启注解:

@Spy
List list = new LinkedList();

5、使用部分模拟来完成对局部变量的替换

假设我们要测试这样一段代码:

Request request = new Request();

// 设置request的属性
...

// 调用方法
Response response = serviceInvoker.invoke(SERVICE_NAME, request);

如果我们想模拟invoke方法的行为,很难准确的确定request这个参数,即使创建一个相同的对象,设置其行为:

// 创建request对象并设置其属性
Mockito.when(serviceInvoker.invoke(SERVICE_NAME, request)).thenReturn("foo");

这样也是行不通的,因为在待测试的代码中,request是一个局部变量,它的地址和我们创建出来的对象地址是不同的,也就无法准确的进行模拟。

这种情况解决方案是在待测试代码中将创建request的方法抽取出来:

Request request = getRequest();

// 调用方法
Response response = serviceInvoker.invoke(SERVICE_NAME, request);

然后在UT中,首先mock这个方法getRequest,使其返回值是我们控制好的request对象,然后再进行测试即可,这样就能将我们预期的request对象放入方法中了:

// 创建request对象并设置其属性
Request request = new Request();
...

// 模拟getRequest方法的行为
Mockito.when(instance.getRequest()).thenReturn(request);

// 完成我们一开始想要的行为定义
Mockito.when(serviceInvoker.invoke(SERVICE_NAME, request)).thenReturn("foo");

@InjectMocks

日常开发过程中,另外一个常用的注解是@InjectMocks,用它标注的类会自动装配其中已经被@Mock和@Spy标注的字段:

// ModelDaoImpl类中有一个字段mediator, 这里自动装配其中的mediator字段
@InjectMocks
ModelDaoImpl modelDao; 

@Mock
Mediator mediator;

...{
    // 这里调用的create是真实的方法,这里面如果有mediator调用某个方法,就可以通过自动装配事先设置它的行为了
    Mockito.when(mediator.get(0)).thenReturn("foo");
    modelDao.create();
    ...
}

PowerMock

PowerMock可以来配合Mockito使用,模拟静态方法的行为。

1、使用前的准备

需要在测试类上加注解:

@RunWith(PowerMockRunner.class) // 一个固定的启动类
@PrepareForTest({Factory.class}) // 设置要模拟的静态方法对应的类

2、设置静态方法、或者新建对象的行为:

PowerMockito.mockStatic(Factory.class); // 用spyStatic可以部分模拟,在每次设置行为前都要执行该方法
PowerMockito.when(Factory.getLogger()).thenReturn(logger); // 设置Factory.getLogger()方法返回值

PowerMockito.doThrow(new RunTimeException()).when(Factory.class) // 执行返回值为void的方法时抛出异常

PowerMockito.whenNew(MyClass.class).withNoArguments().thenThrow(new IOEeception()); // 新建对象时抛出异常

3、验证静态方法、或者新建对象的行为:

// 检查getLogger是否调用了2次
PowerMockito.verifyStatic(Mockito.times(2));
Factory.getLogger();

// 检查getLogger是否调用了1次
PowerMockito.verifyStatic(); // default times is once
Factory.getLogger();

// 检查getLogger是否从未被调用
PowerMockito.verifyStatic(Mockito.never());
Factory.getLogger();

// 是否新建过MyClass类的对象
PowerMockito.verifyNew(MyClass.class).withNoArguments();

4、私有方法的模拟与验证:

// classUnderTest调用私有方法methodName,参数为parameter时,返回值为value
PowerMockito.doReturn(value).when(classUnderTest, "methodName", "parameter");

// classUnderTest是否调用两次私有方法methodName,参数为parameter
PowerMockito.verifyPrivate(classUnderTest, Mockito.times(2)).invoke("methodName", "parameter");
posted on 2022-01-10 14:36  岚者小轩  阅读(2075)  评论(0编辑  收藏  举报