With Mockito, how do I verify my lambda expression was called?

Question

I am trying to test a method that takes a Consumer function, and I want to verify with Mockito that my lambda expression is called exactly once. What I'm using now is the kind of clunky way of using a flag on a final, single-element array:

final boolean[] handlerExecuted = {false};
instance.conditionalRun(item -> {
  handlerExecuted[0] = true;
  item.foo();
});

Assert.assertTrue(
    "Handler should be executed.",
    handlerExecuted[0]);

It seems like there should be a better way (with a Mockito spy, perhaps) to verify that this lambda expression was called exactly once.

Answer 1

Some of the other answers offer alternatives to doing exactly what I want here, but this is doable by Spying the Consumer class itself and having the spy call the method you really want to execute. A helper method for wrapping the lambda to create the spy helps here:

/** Get a spied version of the given Consumer. */
private Consumer<Item> itemHandlerSpy(Consumer<Item> itemHandler) {
  // Create a spy of the Consumer functional interface itself.
  @SuppressWarnings("unchecked")
  Consumer<Item> spy = (Consumer<Item>) Mockito.spy(Consumer.class);
  // Tell the spy to run the given consumer when the Consumer is given something to consume. 
  Mockito.doAnswer(it -> {
    // Get the first (and only) argument passed to the Consumer.
    Item item = (Item) it.getArguments()[0];
    // Pass it to the real consumer so it gets processed.
    itemHandler.accept(item);
    return null;
  }).when(spy).accept(Mockito.any(Item.class));
  return spy;
}

And then the test method becomes very straightforward:

Consumer<Item> itemHandler = itemHandlerSpy(Item::foo);
instance.conditionalRun(itemHandler);
// This verifies conditionalRun called the Consumer exactly once.
Mockito.verify(itemHandler).accept(Mockito.any(Item.class));

Answer 2

You can verify that your method was called with any lambda expression was called like this:

    verify(someClass).myMethodThatExpectsALambda(any())

    private fun <T> any(): T {
        Mockito.any<T>()
        return null as T
    }

Answer 3

Your ways can also verify that is invoked exactly once by replacing boolean[] with int[], for example:

final int[] calls = new int[1];

instance.conditionalRun(item -> {
    calls[0]++;
    item.foo();
});

Assert.assertEquals(1, calls[0]);

Note: using mockito is more complicated since you called item.foo() later.

Edit

After thinking I found that your test testing more than one behavior that result in the test is complicated, for more details you can see Why should unit tests test only one thing?, and the test can be separated at least as below since I see the intention of your test code:

@Test
void runOnceWhenConditionIsSatisfied() throws Throwable {
    final int[] calls = new int[1];

    instance.conditionalRun(item -> calls[0]++);

    Assert.assertEquals(1, calls[0]);
}

@Test
void anotherTest() throws Throwable {
    instance.conditionalRun(item -> {
        item.foo();
    });
    //... testing your SUT here 
}

AND then you can happy to replace State Verification with Behavior Verification by using mockito as below.

@Test
void runOnceWhenConditionIsSatisfied() throws Throwable {
    Consumer<T> it= Mockito.mock(Consumer.class);
    //       ^--- T is the type of item

    instance.conditionalRun(it);

    Mockito.verify(it,Mockito.only()).accept(Mockito.any());
    // using any to ignore matching the parameters ---^
}

Answer 4

You can always replace your lambda expression with an anonymous inner class - or a mock of the right interface (Consumer). And then you can verify your mock as usual.

Answer 5

that takes a Consumer function - ok... , but how do you pass the Object to that consumer? A Consumer is well a method that returns void and takes item as input. So you either pass item to the method (as an argument) or create it inside the method. Either way you need to mock item and assert that it calls foo only once, not the lambda expression.

Since lambda expressions are de-sugared to methods (with a compiler generated name), I can't really think of a way to mock that - you would need the name to be mocked after all. Things would be more complicated if you use a Method Reference that might not be de-sugared by the compiler at all.