Mockito error with custom matcher

Question

I have a Java class:

  import java.util.List;
  public class Service
  {
     public List<Object> someMethod(final List<Object> list) {
        return null;
     }
  }

And a Spock test where I've defined a custom matcher:

import org.mockito.ArgumentMatcher import spock.lang.Specification

    import static org.mockito.Mockito.*

    class InstantBookingInitialDecisionTest extends Specification {

        def mock = mock(Service.class)

        def setup() {
            when(mock.someMethod(argThat(hasSize(2)))).thenReturn([])
            when(mock.someMethod(argThat(hasSize(3)))).thenReturn([])
        }

        def 'Minimum hunger requirements do not apply to schedulable pros'() {
            when:
            'something'
            then:
            'something else'
        }

        // Damn, there's a Hamcrest matcher for this, but it's not in the jar that the javadocs say it is, so making my own
        static def hasSize(size) {
            new ArgumentMatcher<List>() {
                @Override
                boolean matches(Object o) {
                    List list = (List) o
                    return list.size() == size
                }
            }
        }
    }

As is, this test gives me the following error:

java.lang.NullPointerException: Cannot invoke method size() on null object

If I remove either one of the when's, I get no error. So what it doesn't like is the stubbing portion of the test, and the fact that I used the custom matcher twice.

Notes:

1. I've tried declaring a separate class for each list size, as in mockito anyList of a given size and the Mockito documentation. I get the same error.
2. I've tried to use the Hamcrest matcher that looks like this, but despite the fact that the 1.3 Javadocs lists a Matchers.hasSize() method, my imported 1.3 jar does not include Matchers. (But even if I got the dependency resolved, I would still like to understand the problem.)

Please do not ask why I am using Mockito instead of Spock Mocks - I have my reasons. ;)

Thank you

Answer 1

The root cause is that your custom matcher can throw exceptions, which doesn't comply with Matcher's general contract. You're running into it in when because of Mockito's internals.

Matcher's contract states that matches(Object) can accept any Object and return true or false. This means that in every single Matcher implementation, you should make no assumptions about the type of the object passed in, or whether the object is non-null; after all, isNull() is a perfectly valid and useful matcher. If you want your Matcher to return false for any null or non-List argument, you should check that manually, or extend TypeSafeMatcher<List> instead of BaseMatcher so that Hamcrest can return false for you in those cases. Otherwise, you risk an uncaught ClassCastException or NullPointerException, which is what you're getting here. That's the only real problem here, and fixing it will solve your trouble.

---

This is a good moment, though, to explain Mockito's syntax. You don't have trouble with the first line, so why would the second fail? The answer is that when your second line runs:

when(mock.someMethod(argThat(hasSize(3)))).thenReturn([])

...then Java evaluates the call to when, so it runs:

     mock.someMethod(argThat(hasSize(3)))

...and then when can detect someMethod as the last method called and start its stubbing. Like for all other Mockito matchers, the call to argThat returns null (keeping its side effect in a stack Mockito can analyze when Java calls when later), but someMethod has to have a return value and Mockito can't detect that you're about to call when. This means checking for existing stubs, so it pipes the null from argThat into your Matcher to see if it should apply your first stub, which causes the NullPointerException. (I put a little more about argThat's return value and Mockito's evaluation order in another SO answer.)

You'll want to fix up your Matcher anyway, but it's also possible for you to have rephrased the second line as follows:

doReturn([]).when(mock).someMethod(argThat(hasSize(3)))

...because the call to when before someMethod means that Mockito can temporarily disarm your stubbing. As long as the first line doesn't throw an exception or call real implementations, though, there's no harm in leaving your syntax as when, and Mockito will handle verification gracefully.