Mockito 中捕获 mock 对象方法的调用参数

Mockito 可以帮助我们创建 Mock 对象，mock 被调用的方法，断言调用次数，在方法参数不易确定的情况下还能帮我们捕获参数。下面是我们第一个问题:

为什么要捕获调用参数

在被 mocker 方法调用参数明确的情况下可无需捕获参数，例如，下面的情景：

@Test
public void dontCaptureArgument() {
  UserDao userDao = Mockito.mock(UserDao.class);
  UserService userService = new UserService(userDao);

  User user = new User(1, "Yanbin");
  userService.saveUser(user); //假如它的实现是 userDao.save(user)

  verify(userDao, times(1)).save(user); //断言了 userDao.save(user) 操作的还是 user 对象
}

如果 UserService 的 save(user) 最终操作的不是同一个对象，它的实现稍加变化如下

public class UserService {
  private UserDao userDao;

  public void save(User user) {
    User revisedUser = new User(SequenceGenerator.next(), user.name);
    userDao.save(revisedUser);
  }
}

由于在调用 userDao.save(revisedUser) 时的参数已不是传入 `userService.saveUser(user)` 的那个 user 对象了，所以继续用

verify(userDao, times(1)).save(user);

断言就要失败了，出现类似下面的信息

就是断言的 user 实现与 userDao 实际接受到的实例是不一样的。这时候我们可以选择懒堕一点，忽略参数的因数，只关心是否仅被调用一次，可写成

verify(userDao, times(1)).save(any(User.class));
verify(userDao, times(1)).save(any());  //或懒到极致一点

但用 any() 的话我们会有些缺乏安全感，太含糊，可能实际传递给 userDao 的的 user  对象根本不是我们想期望的。

当然如果我们清楚知道 user.name 不会变的，我们可以用 `ArgumentMatcher` 来匹配参数

verify(userDao, times(1)).save(argThat(user1 -> user1.name.equals(user.name)));

如果你所用的 mockito 版本不够高的话，`ArgumentMatcher` 可能还不是个 FunctionalInterface, 就得老老实实的用匿名类， new ArgumentMatcher(){...} .

注: 在写在此文时用的 mockito-core-2.6.2. 有些项目中或许仍在用 mockito-all 引入 mockito 依赖，这种方式无法引入 Mockito 2.*. 见 mockito 官方的说明 Declaring mockito dependency .

使用 argThat(ArgumentMatcher) 进行参数特征匹配也算是不错的方案，除此之外我们还有另一种办法，捕获参数后作事后断言。或是我们在给方法打桩时用 any() 参数，然后事后断言

when(userDao.findUserLike(any()).thenReturn(Mockito.mock(User.class)); //我们在后面的 verify() 中捕获 any() 所对应的的实际参数

至此，对于为什么要捕获调用参数我都觉得未完全叙述清楚。没关系可跳到下一节中从实现中进一步体会。

如何捕获 mock 方法的调用参数

下面是一个简单的例子，只捕获一次调用的参数

@Test
public void captureNonGenericArgument() {
  UserDao userDao = Mockito.mock(UserDao.class);
  UserService  userService = new UserService(userDao);

  userService.saveUser(new User(null, "Yanbin"));
  
  ArgumentCaptor<User> argumentCaptor = ArgumentCaptor.forClass(User.class);
  verify(userDao, times(1)).save(argumentCaptor.capture());

   assertEquals("Yanbin", argumentCaptor.getValue().name);
   assertEquals("Chicago", argumentCator.getValue().city); //可断言捕获参数的更多特征
}

从面对被捕获参数 argumentCaptor.getValue() 的断言可看出它比 argThat() 的优势，argThat() 无法告诉我们不匹配的细节，下面是 argThat() 代码的测试失败信息

verify(userDao, times(1)).save(argThat(user -> user.name.equals("error")));

Argument(s) are different! Wanted:

userDao.save(

<User service test$$ lambda$ 1/ 2 0 8 7 8 8 5 3 9 7>

);

-> at cc.unmi.UserServiceTest.captureNonGenericeArgument(UserServiceTest.java:27)

Actual invocation has different arguments:

userDao.save(

cc.unmi.User@6c64cb25

);

-> at cc.unmi.UserService.saveUser(UserService.java:16)

而针对被捕获到的参数进行断言就自由多了，是 name 还是 city 属性不对从失败信息中会显示得清清楚楚。

捕获多次调用的参数

假如被 mock 方法会被调用多次，该如何知道每次调用时的参数呢？argumentCaptor.getValue() 只会返回最后一次调用的参数值

@Test
public void captureNonGenericeArgument() {
    UserDao userDao = Mockito.mock(UserDao.class);
    UserService  userService = new UserService(userDao);

    userService.saveUser(new User(null, "Yanbin"));
    userService.saveUser(new User(null, "Unmi"));  //这里手工模拟产生两次对 userDao.save(user) 的调用

    ArgumentCaptor<User> argumentCaptor = ArgumentCaptor.forClass(User.class);
    verify(userDao, times(2)).save(argumentCaptor.capture());

    assertEquals("Yanbin", argumentCaptor.getValue().name);
}

上面代码得到错误信息

说明 argumentCaptor.getValue() 仍然在工作，只是保存最近一次调用的参数值，而想要获得所有调用的参数值必须用  argumentCaptor.getAllValues() , 它返回一个 List<T>.

@Test
public void captureNonGenericeArgument() {
    UserDao userDao = Mockito.mock(UserDao.class);
    UserService userService = new UserService(userDao);

    userService.saveUser(new User(null, "Yanbin"));
    userService.saveUser(new User(null, "Unmi"));

    ArgumentCaptor<User> argumentCaptor = ArgumentCaptor.forClass(User.class);
    verify(userDao, times(2)).save(argumentCaptor.capture());

    List<User> inputUsers = argumentCaptor.getAllValues();

    assertEquals(2, inputUsers.size());
    assertTrue(inputUsers.stream().allMatch(user ->
        Arrays.asList("Yanbin", "Unmi").contains(user.name))
    );
}

对于 argumentCaptor.getAllValues() 得到的 List<T> 可以按需进行断言，比如 mock 方法是异步无序调用的，则可以用 Stream 的  allMatch() 或 anyMatch() 去匹配断言。

捕获带泛型的参数

原本写作此文的目的只作研究如何捕获带泛型的参数，没想从头至此说了那么内容才进入到初衷。

JDK 自从 1.5 加入了泛型那已经是很多年前的事了，可如今 Mockito 的官方网站 http://site.mockito.org 的 How 里例子还是不为 List 声明具体类型的

List mockedList = mock(List.class);
mockedList.add("one");
verify(mockedList).add("one");

以上代码放到现代 IDE 都会被警告的，虽然 List 是 List<Object> 的意思, 但 IDE 不希望你把 List<Object> 简化为 List 。

给 UserService 增加一个方法 saveUsers(List<User> users)

public void saveUsers(List<User> users) {
    userDao.save(users); //UserDao 中增加相应的 save(List<User> users) 方法
}

下面的测试方法的确是可以工作

@Test
public void captureGenericeArgument() {
    UserDao userDao = Mockito.mock(UserDao.class);
    UserService userService = new UserService(userDao);

    userService.saveUsers(Collections.singletonList(new User(null, "Yanbin")));

    ArgumentCaptor<List<User>> argumentCaptor = ArgumentCaptor.forClass(List.class);
    verify(userDao, times(1)).save(argumentCaptor.capture());

    assertEquals(1, argumentCaptor.getValue().size());
    assertEquals("Yanbin", argumentCaptor.getValue().get(0).name);
}

但是无法给 ArgumentCaptor.forClass(List.class) 指定更内层的类型 User, 它的方法原型参数是 forClass(Class clazz) , 所以代码行

ArgumentCaptor<List<User>> argumentCaptor = ArgumentCaptor.forClass(List.class);

有一个不安全类型赋值

如果代码规范或 Maven 要求严格就必须给该测试方法加上 @SuppressWarnings("unchecked") 注解来消除警告。还有别的办法呢？

因为 Java 的泛型擦除的实现方式，所以从语法上下面的写法也是不合法的

ArgumentCaptor<List<User>> argumentCaptor = ArgumentCaptor.forClass(List<User>.class); //这是错的

好在 Mockito 也为我们考虑到了，还有 @Captor (Since 1.8.3) 注解，它像用 @Mock 声明 mock  对象一样声明捕获参数, 使用方法如下

@RunWith(MockitoJUnitRunner.class)
public class UserServiceTest {

    @Captor
    private ArgumentCaptor<List<User>> argumentCaptor;

    @Test
    public void captureGenericeArgument() {
        UserDao userDao = Mockito.mock(UserDao.class);
        UserService userService = new UserService(userDao);

        userService.saveUsers(Collections.singletonList(new User(null, "Yanbin")));

        verify(userDao, times(1)).save(argumentCaptor.capture());

        assertEquals(1, argumentCaptor.getValue().size());
        assertEquals("Yanbin", argumentCaptor.getValue().get(0).name);
    }
}

和使用 Mockito 的其他注解一样，需要

@RunWith(MockitoJUnitRunner.class)

指定 Junit Runner，或者是在运行测试前手工初始化，像

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

相对来说用 @RunWith(MockitoJUnitRunner.class) 简单些，但 @RunWith 是独占的，比如在指定了其他 JUnit Runner(例如 @RunWith(SpringJUnit4ClassRunner.class) ) 时，又要使用 Mockito 的注解，那我们就必须手工调用 MockitoAnnotations.initMocks(this) 了。