模拟传递给回调（lambda）的参数

Question

如何使用 Mockito 模拟接受 lambda 的方法，以便能够控制将哪些参数传递给回调？我特别想模拟这样使用的JDBI method useExtension：

jdbi.useExtension(OrgUnitDao.class, dao -> {
    // Skip if already loaded
    // Skip if already loaded
    if (dao.orgUnitsAreLoaded()) {

我想将dao 对象替换回回调中，这样我就可以使用dao.orgUnitsAreLoaded() 的返回值来控制分支。

签名是这样的

public <E,X extends Exception> void useExtension(Class<E> extensionType,
                                             ExtensionConsumer<E,X> callback)
                                      throws NoSuchExtensionException,
                                             X extends Exception

Answer 1

这是我问题的完整答案。它被简化为如何进行存根的基本知识，因此不反映我要测试的生产代码，但它准确地显示了执行此操作所需的机制。

final Jdbi jdbi = mock(Jdbi.class);
doAnswer(invocation -> {

    System.out.println("this is the doAnswer lambda - just setting up the answer and the mocks");

    final Class<OrgUnitDao> daoClass = invocation.getArgument(0);
    final ExtensionConsumer callback = invocation.getArgument(1);
    final OrgUnitDao mock1 = mock(daoClass);

    when(mock1.orgUnitsAreLoaded()).thenReturn(false);

    // call the actual callback method
    callback.useExtension(mock1);

    return null;

}).when(jdbi).useExtension(eq(OrgUnitDao.class), any());

// This is the method call I am to test
// Regard this as hidden away in some outer method in
// the System-Under-Test, but that I have been able
// to inject all its dependencies
jdbi.useExtension(OrgUnitDao.class, new Foo());

/// Further down, outside of the method

// Only replaced the lambda with this to get toString() for debugging ...
class Foo implements ExtensionConsumer<OrgUnitDao, RuntimeException> {
    @Override
    public void useExtension(OrgUnitDao orgUnitDao) throws RuntimeException {
        System.out.println("A real method call, now using the passed in mocked dao:" + orgUnitDao.orgUnitsAreLoaded());
    }

    @Override
    public String toString() {
        return "OrgUnitDao class";
    }
}

Answer 2

为了与"Calling callbacks with Mockito" 问题的对话并行，您的 lambda 可能会在您的被测方法执行期间同步调用，或者稍后可能会基于某些外部因素或交互来调用。与Dawood's answer there 一样，your answer here 使用 Mockito Answer 将起作用，如果您正在寻找同步样式（其中mockJdbi 在methodUnderTest 返回之前立即调用您的 lambda），这是唯一的方法。如果您的 lambda 将被异步调用，或者如果您的系统允许您异步调用 lambda，您可能希望在您的被测方法返回之后但 在交互之前测试状态与 lambda.

// MockitoJUnitRunner, MockitoRule, or MockitoAnnotations.initMocks populate these.
// Especially useful for the ArgumentCaptor's generic arguments.
@Mock Jdbi mockJdbi;
@Mock OrgUnitDao mockOrgUnitDao;
@Captor ArgumentCaptor<ExtensionConsumer<OrgUnitDao, RuntimeException>>
    extensionConsumerCaptor;

@Test public void yourTest() throws Exception {
  // No stubbing needed! Just create the system under test.
  YourSystemUnderTest systemUnderTest = new YourSystemUnderTest(mockJdbi);

  // Call the method under test, which presumably calls useExtension(...).
  systemUnderTest.methodUnderTest();

  // Assert anything that should be true before the lambda is called.
  assertFalse(systemUnderTest.getSomeState());

  // Confirm that useExtension was called, and simultaneously acquire the lambda.
  // ArgumentCaptor.capture() is a matcher, so every argument requires a matcher like eq.
  verify(mockJdbi).useExtension(eq(OrgUnitDao.class), extensionConsumerCaptor.capture());

  // Prepare the mock DAO and call the lambda.
  when(mockDao.getFoo()).thenReturn("bar");
  extensionConsumerCaptor.getValue().useExtension(mockDao);

  // Assert anything that should be true after the lambda is called.
  assertTrue(systemUnderTest.getSomeState());
}

虽然 lambda 减少了以前与匿名内部类相关联的样板，但您可能也更喜欢使用 Captor 样式，因为它使您免于创建冗长的 Answer 实现并在其中隐藏您的测试断言或 Mockito 验证。如果您的项目更喜欢具有清晰的“given-when-then”结构的 BDD 样式模拟，这尤其诱人（尽管我的示例更接近于“given-when-then-when-then”）。