以下内容不会涉及其中原理,只使用简单的、可能不正确的叙述来帮助理解方法的表现作用。
1. Mockito.mock 和 Mockito.spy 的不同
Mockito.mock 通常的用法是:A obj = Mockito.mock(A.class);
Mockito.spy 通常的用法是:A obj = Mockito.spy(new A());
Mockito.spy()与new的区别在于,spy()包装后的对象,可以使用Mockito.when()、Mockito.verify()对此对象的方法调用进行设定与验证
Mockito.mock() 创建出来的对象,在调用该对象中的某个方法时,不会执行其它方法。
Mockito.spy() 创建出来的对象,在调用该对象中的某个方法时,会执行其它方法。
- 结合示例说明使用效果:
1. UserService service = Mockito.mock(UserServiceImpl.class);
2. service.deleteById(1);
3. UserService service = Mockito.spy(new UserServiceImpl());
4. service.deleteById(1);
class UserService {
public int deleteById(long id) {
User u = this.selectById(id);
if (u != null) {
return this.mapper.deleteById(id);
}
// do something
}
public User selectById(long id) {
// do something
}
}
对于 Mockito.mock 而言
第1行代码,使用Mockito.mock()创建出一个UserService对象。
第2行代码,对于deleteById()中涉及到的对this.selectById、this.mapper.deleteById的调用不会执行内部的逻辑,且不会有返回值。
对于 Mockito.spy 而言
第3行代码,使用Mockito.spy()包装了一下开发者自己创建的UserService对象。
第4行代码,对于deleteById()中涉及到的对this.selectById、this.mapper.deleteById的调用会执行内部的逻辑。
基于单元测试的基本思想——自扫门前雪
,被测试的方法
不应该因为外部方法的逻辑报错
而测试失败。
因此 Mockito.mock() 是常用的。
但Mockito框架
不能完成对private方法
的测试(被认为具有破坏性),而为了达到测试private方法
的目的,可以使用一个public方法
作为引子,再结合 Mockito.spy() 完成此目的。
Mockito.spy() 不常用但会用到,
它引发的整个方法链路的调用,这破坏了单元测试的基本思想,但也弥补了 Mockito.mock() 做不到的事情。
2. @Mock 与 @Spy 的不同
这两个注解是Mockito.mock 和 Mockito.spy的注解版,可以像使用依赖注入一样在类中定义为类属性。
达到的作用是一样的。
public class UserServiceImplTest {
@Mock / @Spy
UserServiceImpl userService;
}
@InjectMocks
的作用类似于Spring中的@Autowired
@Spy
@InjectMocks
private CommandManager commandManager;
CommandManager 构造函数中需要的参数,会从其它@Mock、@Spy的对象中自动选取。
3. Mockito.when().thenXX() 的使用(作用:模拟方法调用)
这个方法对于 Mockito.mock()、Mockito.spy() 没有区别,都能起到一样的作用。
这里还是要基于 标题1 中的示例进行使用说明
class UserService {
public int deleteById(long id) {
User u = this.selectById(id);
if (u != null) {
return this.mapper.deleteById(id);
}
// do something
}
public User selectById(long id) {
// do something
}
}
回到单元测试的基本思想——自扫门前雪
上,
开发者A测试deleteById()
时,不想关注外部方法的逻辑,只想保证内部的判断、步骤的执行顺序正确,
但判断的执行条件需要其它方法的返回值(如:u != null),
为了能不受外部方法牵连、扯后腿,又能够模拟外部方法的执行结果,就需要用到Mockito.when().thenXX()
- 结合使用示例进行说明
1. UserService userService = Mockito.mock(UserService.class);
2. Mockito.when(userService.selectById(1)).thenReturn(new User()); // 声明:当调用目标方法的行为发生后,执行指定的return行为。
3. Mockito.when(userService.selectById(2)).thenReturn(new User());
4. userService.deleteById(1);
第4行代码,在运行到方法内部,需要去执行User u = this.selectById(id)
时,会触发第2行代码声明的行为(不会触发第3行的声明,因为参数不对应)
因此,灵活地使用Mockito.when().thenXX()
,对于目标方法的单元测试,就能够起到忽视外部因素影响的作用,专心擦自己的屁股。
when().thenReturn()、when().thenThrow()、when().thenAnswer() 都是类似的效果,
即:当when()声明的行为发生后,执行自定义的then操作
4. Mockito.doXXX().when().xxx() 的使用(作用:模拟方法调用)
其使用思路与
Mockito.when().thenXX()
一致
Mockito.when().thenXX()
要求目标测试方法
不能使用 void 作为方法返回值
;
Mockito.doXXX().when().xxx()
没有这个要求,如果目标测试方法
的返回void,使用doNothing()即可。
- 使用示例
1. UserService userService = Mockito.mock(UserService.class);
2. Mockito.doReturn(new User()).when(userService).selectById(1);
3. userService.deleteById(1);
此示例的执行效果与 标题3 中的示例,是一样的执行效果。
5. Mockito.anyXX() 的使用(作用:模拟参数)
在上面的 标题3、标题4 的实例中,方法的参数都是指定的常量,但系统在上线使用时参数约等于随机的,
因此指定常量作为参数的测试,是容易有测试盲点的。
而 Mockito.anyXX()
可以解决这个问题
Mockito.doReturn(new User()).when(userService).selectById(1);
变更为
Mockito.doReturn(new User()).when(userService).selectById(Mock.anyLong());
这样的变更,表示只要调用了selectById
,不管selectById
的传入参数是什么,都会触发之前声明的行为。
6. Mockito.verify().xxx() 的使用(作用:验证设想)
类似于
Assertions.assertXXX()
,只不过是对方法调用层面的验证。
通常用于验证程序是否按要求退出、条件判断是否写反、条件判断的逻辑是否如预期那样执行
。
通常用法为:
Mockito.verify(userService, Mockito.never()).selectById(Mockito.any()); // 目标方法在测试中是否从来没执行
Mockito.verify(userService, Mockito.times(1)).selectById(Mockito.any()); // 目标方法在测试中是否只执行了1次
- 结合使用示例进行说明
// 基础类结构
class ServiceA {
public void a(int i) {
if (i == 1) {
this.b()
}
// do something
}
public void b() {
// do something
}
}
// 测试代码的编写
@Test
void testA() {
ServiceA service = Mockito.mock(ServiceA.class);
service.a(1);
Mockito.verify(service, Mockito.times(1)).b(); // 当a方法的传入值为1时,是否执行了一次b方法
service.a(2);
Mockito.verify(service, Mockito.never()).b(); // 当a方法的传入值为2时,是否从不执行b方法
}
7. Mockito.mockStatic() 的使用(作用:模拟静态方法调用)
类似于
Mockito.mock() + Mock.when()
或Mockito.mock() + Mock.verify()
的用法
Mockito.mockStatic()
在使用后必须调用close()
方法关闭,因此最好以try(xx) {}
的方式使用;
Mockito.mockStatic()
使用when()
须在后面跟thenXXX()
;
目标静态方法无返回值
时, when()
后不能用thenReturn()
,但可以用thenThrow()
;
Mockito.mockStatic()
是范围工作的 ,因此,调用此静态方法的目标代码必须在其生效范围内编写;
- 示例1 - 有返回值的静态方法
try (MockedStatic<NettyChannelMap> mockStatic = Mockito.mockStatic(NettyChannelMap.class)) {
mockStatic.when(() -> NettyChannelMap.getEquipmentChannel(Mockito.anyString())).thenReturn(new NioSocketChannel());
southboundDataService.handleCommandRequest1(equipmentCode, reboot); // 要测试的目标方法
}
- 示例2 - 无返回值的静态方法
try (MockedStatic<ProtocolDataHandler> mockStatic = Mockito.mockStatic(ProtocolDataHandler.class);) {
commandManager.control(cc);
mockStatic.verify(() -> ProtocolDataHandler.sendDown(Mockito.any(), Mockito.anyInt()), Mockito.times(1));
}
8. 模拟内部类的对象 与 类内部的属性的使用
public class A {
@Getter
public B b = new B();
public void a() {
this.getB().b();
}
public static class B {
public void b() {}
}
}
在如上的代码中,想要模拟b.b()
的调用需要使用如下的测试代码
@Spy / @Mock
private A a;
@Test
public void testA() {
A.B b = Mockito.mock(A.B.class);
Mockito.when(a.getB()).thenReturn(b);
Mockito.doNothing().when(b).b();
a.a();
Mockito.verify(b, Mockito.time(1)).b();
}
9. Mockito 模拟与忽略 Thread.sleep() 或 TimeUtil.XXX.sleep()
默认情况下,Mockito是不允许
模拟Thread的,因此需要增设一个自己的类来包裹Thread.sleep()
操作
public class Sleeper {
public static void sleep(TimeUnit timeUnit, long val) throws InterruptedException {
timeUnit.sleep(val);
}
}
在业务代码
需要使用 sleep 的地方,替换为使用Sleeper.sleep()
来完成目的。
再测试时,使用Mockito.mockStatic(Sleeper.class)
的操作来代替对Thread
或者TimeUtil
的模拟。
try (MockedStatic<Sleeper> mockStatic = Mockito.mockStatic(Sleeper.class)) {
// ... 测试逻辑
mockStatic.verify(() -> Sleeper.sleep(Mockito.any(), Mockito.anyLong()), Mockito.never());
}
10. 不要模拟无限循环
对于无限循环,应该将循环内部的代码放入单独的方法中,测试时,使用Mockito对这个单独出来的方法进行测试。