How to resolve Unnecessary Stubbing exception

java

mockito

testing

best-practices

byAnton Shumikhin·Oct 26, 2024

Defeat the pesky UnnecessaryStubbingException by only stubbing methods that your test calls. Redundant stubs are like cobwebs in your code, the more they pile up, the more confusing it gets.

// Stub - only done when it's absolutely "necessary" (get it? 😉)
when(mockedObject.action("use")).thenReturn("result");

// Test using the stub - If you stub it, use it 🙃
assertThat(mockedObject.action("use"), is("result"));

Take it up a notch: inspect your tests for correct actual usage, utilize methods to suppress the exception where needed, and refactor.

Troubleshooting: Identify common issues

When dealing with the UnnecessaryStubbingException, you should analyze your tests to uncover flaws causing the issue:

Mismatched method mocking

Ensure no method is stubbed which isn't called. Go through the logic in your test and confirm whether the stubbed method aligns with the methods invoked.

Failure before stub usage

Tests failing before the stubbed method is involved can also trigger the exception. Keep an eye out for assertions or operations that could be throwing errors unexpectedly.

Incorrect branching

Your code may have various paths, ensure your stubs match the actual execution path taken.

Maintaining code cleanliness

Cull your tests regularly for unused stubbings, especially in legacy projects. An up-to-date test suite doesn’t only ensure correctness but also improves readability and navigability.

Strategies: Controlling Mockito's strictness

There might be some tests with complex setups where unused stubs might be necessary. You can adjust Mockito's strictness levels to avoid this exception:

JUnit 4 strategies

Give Mockito a chill pill by leaning on MockitoJUnitRunner.Silent or setting MockitoJUnit.rule().strictness(Strictness.LENIENT).

// Running silent, like a cat in socks on a carpet! 😸
@RunWith(MockitoJUnitRunner.Silent.class)
public class MyTestClass {

    // Test code here

}

JUnit 5 strategies

Servicing JUnit 5? The @MockitoSettings annotation adjusts strictness levels to suit your needs.

// JUnit 5 got strictness exactly of Grandpa kind: not too much, but enough.
@MockitoSettings(strictness = Strictness.LENIENT)
class MyTestClass {
    
    // Test code here
    
}

Mockito's lenient API

The lenient() API available from mockito-core 2.23.0+ lets you set stubbing strictness, use when necessary.

// lenient(): The Sunday of APIs, where anything goes 😉
lenient().when(mockedObject.someMethod()).thenReturn(someValue);

Quality checks: Refactoring for clarity

A good test is not just about making it pass or fail. Readability and maintainability are critical:

Purposefulness of stubbing

All stubbed methods should serve a purpose, know why you're using them and what they contribute.

Optimal use of mocking

Refactor tests so that they're more effective, creating robust and adaptable tests.

Checklist for proactive prevention

Here's a handy checklist to ward off the dreaded Unnecessary Stubbing Exceptions:

Verify Mock Stations: Ensure each stub plays a crucial part in the test scenario.
Line them Up: Align stubs with the methods under test.
Review Test Process: Consider the paths your test is traversing.
Frequent Overhauls: Routinely updating tests ensures they're effective and efficient.
Mockito Warnings as Tips: Use guidance from Mockito to spot potential areas of improvement.
Compile and Try: Double-check if tests are passing and code is compiling before dismissing any stubs as "unnecessary".

Adhering to these principles retains your testing suite's integrity, making it more effective.

explain-codes / Java / How to resolve Unnecessary Stubbing exception

Linked

Mockito - NullpointerException when stubbing Method



How to test that no exception is thrown?



When I run mockito test occurs WrongTypeOfReturnValue Exception



Mockito - difference between doReturn() and when()



Difference Between @Mock and @InjectMocks