以下内容不会涉及其中原理，只使用简单的、可能不正确的叙述来帮助理解方法的表现作用。
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对这个单独出来的方法进行测试。
网友评论