Mocking Functional Interfaces with Mockito in Java

Functional interfaces are a cornerstone of modern Java development, especially after Java 8 introduced lambda expressions and the java.util.function package. These interfaces help decouple logic, simplify code, and boost readability.

However, testing these lambda-driven constructs can become tricky, particularly when using dependency injection or when lambdas encapsulate external behavior. This is where mocking frameworks like Mockito shine.

In this tutorial, you’ll learn how to mock Java functional interfaces using Mockito, enabling cleaner, more testable, and maintainable code.

Why Mock Functional Interfaces?

Mocking is crucial when you want to:

• Isolate behavior in unit tests.
• Avoid executing actual logic like API calls, DB operations, or external systems.
• Verify interaction (e.g., verify(consumer).accept(...)).

You might use functional interfaces like Consumer, Supplier, Function, Predicate, or custom ones in your production code. With Mockito, you can mock these just like any other Java class or interface.

---

🔧 Prerequisites

• Java 8 or later (examples tested with Java 17 and Java 21)
• Mockito 4.x or later
• JUnit 5

---

Mocking Built-in Functional Interfaces

Example: Mocking a Consumer

@Test
void testConsumerMock() {
    Consumer<String> mockConsumer = mock(Consumer.class);
    
    mockConsumer.accept("Hello");
    
    verify(mockConsumer).accept("Hello");
}

Example: Mocking a Function

@Test
void testFunctionMock() {
    Function<Integer, String> mockFunction = mock(Function.class);
    when(mockFunction.apply(5)).thenReturn("Five");

    String result = mockFunction.apply(5);

    assertEquals("Five", result);
    verify(mockFunction).apply(5);
}

Example: Mocking a Predicate

@Test
void testPredicateMock() {
    Predicate<String> mockPredicate = mock(Predicate.class);
    when(mockPredicate.test("apple")).thenReturn(true);

    boolean result = mockPredicate.test("apple");

    assertTrue(result);
    verify(mockPredicate).test("apple");
}

---

🧪 Mocking Custom Functional Interfaces

If you’ve defined your own functional interfaces, Mockito supports those too.

Example:

@FunctionalInterface
public interface Calculator {
    int calculate(int a, int b);
}

@Test
void testCustomFunctionalInterface() {
    Calculator calculator = mock(Calculator.class);
    when(calculator.calculate(2, 3)).thenReturn(5);

    int result = calculator.calculate(2, 3);

    assertEquals(5, result);
    verify(calculator).calculate(2, 3);
}

---

📌 What's New in Java for Lambda Testing

• Java 8: Introduced lambdas and java.util.function
• Java 9: Optional.ifPresentOrElse() makes lambda logic clearer
• Java 11: Supports var in lambda parameters
• Java 21:
  • Virtual threads compatible with lambdas
  • Scoped values to isolate state in concurrent tasks

---

🧠 Common Pitfalls

• Forgetting to mock return values (when(...).thenReturn(...))
• Not verifying interactions (verify(...))
• Trying to mock final or private lambdas (requires mockito-inline)
• Using stateful lambdas without proper isolation in tests

---

🤖 Real-world Example

Spring Service Injecting a Functional Interface

@Service
public class NotificationService {

    private final Consumer<String> notifier;

    public NotificationService(Consumer<String> notifier) {
        this.notifier = notifier;
    }

    public void notifyUser(String message) {
        notifier.accept(message);
    }
}

Unit Test

@Test
void testNotificationService() {
    Consumer<String> mockNotifier = mock(Consumer.class);
    NotificationService service = new NotificationService(mockNotifier);

    service.notifyUser("Alert!");

    verify(mockNotifier).accept("Alert!");
}

---

✅ Conclusion and Key Takeaways

• Java functional interfaces can be easily mocked using Mockito.
• This improves unit testing, modularity, and test coverage.
• Works well with built-in (Consumer, Function, Predicate, etc.) and custom functional interfaces.
• Lambdas and mocks fit perfectly into modern Java development practices.

---

❓ FAQ

1. Can you mock a lambda expression directly?

Not directly. You mock the interface the lambda implements.

2. Can Mockito mock java.util.function types?

Yes. All are interfaces and can be mocked.

3. How to mock a Supplier?

Use mock(Supplier.class) and when(...).get().

4. What if my lambda has side effects?

Use doAnswer(...) or verify behavior using verify(...).

5. Can I use method references instead of lambdas in tests?

Yes. Mockito doesn’t care whether you use lambdas or method references.

6. What if I need to mock a lambda that throws an exception?

Use when(...).thenThrow(...).

7. Can I verify that a lambda was not called?

Yes: verify(mock, never()).method().

8. Should I mock all lambdas?

No. Prefer real implementations unless mocking improves test clarity.

9. Does mocking affect performance?

In unit tests, mocking overhead is negligible.

10. Is mockito-inline required?

Only for mocking final classes/methods or static methods.

---