17370845950

本文探讨了在mockito中，当需要验证方法参数是否包含在特定集合中时，如何克服标准`argumentmatchers`的限制。通过利用`argumentmatchers.intthat()`（或`argthat()`）结合lambda表达式，可以灵活地实现自定义的参数匹配逻辑。文章还介绍了如何将此逻辑封装为可复用的辅助方法，以提高代码的可读性和维护性，从而实现类似`in()`的功能。

在单元测试中，我们经常需要使用Mockito来模拟对象行为并验证其交互。ArgumentMatchers提供了多种强大的匹配器来处理各种参数场景，例如any(), eq(), isNull()等。然而，有时我们需要更复杂的匹配逻辑，例如验证一个整数参数是否属于一个特定的值集合。尽管我们可能期望有一个类似in(1, 2, 3)的匹配器，但ArgumentMatchers和AdditionalMatchers中并没有直接提供这样的方法来处理单个参数的集合包含性检查。

挑战：缺失的“in”匹配器

假设我们有一个被模拟的方法签名如下：

List getValuesFor(int arg);

我们希望在when()或verify()中定义一个行为，使其仅当arg的值是1、2或3中的一个时才触发。直接查找in()匹配器会发现它并不存在于Mockito的标准库中。这就要求我们寻找一种替代方案来实现这种自定义的集合包含性验证。

解决方案一：使用 intThat() 结合 Lambda 表达式

Mockito提供了argThat()（用于对象类型）和其原始类型特化版本，如intThat()、longThat()等，允许我们传入一个ArgumentMatcher实例或一个Lambda表达式（它本质上是一个Predicate），来定义任意复杂的匹配逻辑。这是实现集合包含性验证的理想方式。

以下是如何使用intThat()结合Lambda表达式来解决上述问题：

import org.mockito.ArgumentMatchers;
import static org.mockito.Mockito.*;

import java.util.List;
import java.util.Set;

public class MockitoCollectionMatcherExample {

    // 假设这是我们正在模拟的接口或类
    interface MyService {
        List getValuesFor(int arg);
    }

    public static void main(String[] args) {
        MyService mockObject = mock(MyService.class);

        // 使用 intThat() 和 Lambda 表达式定义匹配逻辑
        // 当 getValuesFor 的参数是 1, 2, 3 中的任意一个时，返回特定的 List
        when(mockObject.getValuesFor(ArgumentMatchers.intThat(x -> Set.of(1, 2, 3).contains(x))))
          .thenReturn(List.of(3, 4, 5));

        // 测试调用
        System.out.println("Calling with 1: " + mockObject.getValuesFor(1)); // 预期: [3, 4, 5]
        System.out.println("Calling with 2: " + mockObject.getValuesFor(2)); // 预期: [3, 4, 5]
        System.out.println("Calling with 3: " + mockObject.getValuesFor(3)); // 预期: [3, 4, 5]
        System.out.println("Calling with 4: " + mockObject.getValuesFor(4)); // 预期: null (因为没有匹配到其他行为)

        // 验证调用
        verify(mockObject).getValuesFor(ArgumentMatchers.intThat(x -> Set.of(1, 2, 3).contains(x)));
        // 验证 getValuesFor(4) 未被调用
        verify(mockObject, never()).getValuesFor(4);
    }
}

在上述代码中，ArgumentMatchers.intThat(x -> Set.of(1, 2, 3).contains(x)) 传入了一个Lambda表达式。这个Lambda表达式接收一个int类型的参数x，并返回一个布尔值。如果x包含在{1, 2, 3}这个Set中，则返回true，匹配成功；否则返回false，匹配失败。使用Set.of()创建集合可以确保高效的contains()操作。

注意事项：

• 对于对象类型的参数，应使用ArgumentMatchers.argThat(predicate)。例如，如果方法签名是getValuesFor(Integer arg)，则可以使用argThat(x -> Set.of(1, 2, 3).contains(x))。
• 为了代码简洁，通常会静态导入org.mockito.ArgumentMatchers.*，这样就可以直接使用intThat()而不是ArgumentMatchers.intThat()。

解决方案二：创建可复用的自定义匹配器辅助方法

如果这种集合包含性检查在测试代码中多次出现，或者涉及的集合较大，将Lambda表达式直接嵌入到when()语句中可能会降低可读性。此时，我们可以将匹配逻辑封装到一个辅助方法中，使其更具可读性和可复用性。

import org.mockito.ArgumentMatcher;
import org.mockito.ArgumentMatchers;
import static org.mockito.Mockito.*;

import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

public class MockitoReusableMatcherExample {

    interface MyService {
        List getValuesFor(int arg);
    }

    /**
     * 创建一个 ArgumentMatcher，用于检查 int 参数是否包含在给定值列表中。
     * @param values 期望包含的整数值数组
     * @return ArgumentMatcher 实例
     */
    public static ArgumentMatcher isOneOf(int... values) {
        Set valueSet = Arrays.stream(values).boxed().collect(Collectors.toSet());
        return x -> valueSet.contains(x);
    }

    public static void main(String[] args) {
        MyService mockObject = mock(MyService.class);

        // 使用封装后的辅助方法，代码更简洁易读
        when(mockObject.getValuesFor(ArgumentMatchers.intThat(isOneOf(1, 2, 3))))
          .thenReturn(List.of(3, 4, 5));

        when(mockObject.getValuesFor(ArgumentMatchers.intThat(isOneOf(10, 20))))
          .thenReturn(List.of(100, 200));

        // 测试调用
        System.out.println("Calling with 1: " + mockObject.getValuesFor(1));   // 预期: [3, 4, 5]
        System.out.println("Calling with 10: " + mockObject.getValuesFor(10)); // 预期: [100, 200]
        System.out.println("Calling with 5: " + mockObject.getValuesFor(5));   // 预期: null

        // 验证调用
        verify(mockObject).getValuesFor(ArgumentMatchers.intThat(isOneOf(1, 2, 3)));
        verify(mockObject, times(1)).getValuesFor(ArgumentMatchers.intThat(isOneOf(10, 20)));
    }
}

在这个例子中，我们定义了一个静态辅助方法isOneOf(int... values)。这个方法接收一个变长参数列表，将其转换为Set，然后返回一个ArgumentMatcher实例。这个ArgumentMatcher的matches()方法（由Lambda实现）会检查传入的参数是否在这个Set中。

这种方式的优点在于：

• 可读性增强： intThat(isOneOf(1, 2, 3)) 比内联的Lambda表达式更具描述性，更接近自然语言。
• 代码复用： isOneOf 方法可以在多个测试用例或多个类中复用。
• 维护性： 如果匹配逻辑需要调整，只需修改isOneOf方法即可。

总结

尽管Mockito没有提供直接的in()匹配器来检查单个参数是否属于某个集合，但通过ArgumentMatchers.intThat()（或argThat()）结合Lambda表达式，我们可以轻松实现这一需求。对于更复杂或重复的场景，将匹配逻辑封装到可复用的辅助方法中，可以显著提升测试代码的可读性、可维护性和复用性，使自定义参数匹配变得既强大又优雅。掌握这种技术，能够帮助我们编写更灵活、更健壮的Mockito测试。