Is there a way of having something like jUnit Assert message argument in Mockito's verify method?

Question

Let's assume a snippet of testing code:

Observable model = Class.forName(fullyQualifiedMethodName).newInstance();
Observer view = Mockito.mock(Observer.class);
model.addObserver(view);
for (Method method : Class.forName(fullyQualifiedMethodName).getDeclaredMethods())
{
  method.invoke(model, composeParams(method));
  model.notifyObservers();
  Mockito.verify(
    view, Mockito.atLeastOnce()
  ).update(Mockito.<Observable>any(), Mockito.<Object>any());
}

Mockito.verify method throws an exception if a method in a model hasn't invoked Observable.setChanged() method.

Problem: without adding loggers/System.print.out I can't realize what's the current method that has failed the test. Is there a way of having something similar to jUnit Assert methods:

Assert.assertEquals(
  String.format("instances %s, %s should be equal", inst1, inst2),
  inst1.getParam(), 
  inst2.getParam()
);

---

SOLUTION:

verify(observer, new VerificationMode()
{
  @Override
  public void verify(VerificationData data)
  {
    assertTrue(
        format(
            "method %s doesn't call Observable#setChanged() after changing the state of the model",
            method.toString()
        ),
        data.getAllInvocations().size() > 0);
  }
}).update(Mockito.<Observable>any(), Mockito.<Object>any());

Answer 1

This question is ancient, but Mockito v2.1.0+ now has a built-in feature for this.

verify(mock, description("This will print on failure")).someMethod("some arg");

More examples included from @Lambart's comment below:

verify(mock, times(10).description("This will print if the method isn't called 10 times")).someMethod("some arg");
verify(mock, never().description("This will print if someMethod is ever called")).someMethod("some arg");
verify(mock, atLeastOnce().description("This will print if someMethod is never called with any argument")).someMethod(anyString());

Answer 2

This does the trick (simple and clear):

try {
 verify(myMockedObject, times(1)).doSomthing();
} catch (MockitoAssertionError error) {
    throw new MockitoAssertionError("Was expecting a call to myMockedObject.doSomthing but got ", error);
}

Answer 3

You cannot do in mockito. Mockito syntax makes very easy to test expected behaviour, but it has no concept of test state.

What you're trying to do is to have some information that are not in the mocked object when the mocks fails expectations.

If you really want to do, I see 2 general ways: either you create your own verificationMode implementing the interface

org.mockito.verification;
public static interface VerificationMode

and adding a method like atLeastOnceMsd(String msg) that will show the message in case of failing or adding the current tested method in the model to the view object

for example with a similar line in the inner loop.

  view.setName("now we are testing " + method.getName());

Answer 4

There isn't a direct API call that allows a message on verify. But I think if you change your verify signature to use the method object rather than Mockito.any(), the toString() on the Method class will kick in and give you what you want.

Something like this.

import static org.mockito.Matchers.anyObject;
import static org.mockito.Mockito.atLeastOnce;
import static org.mockito.Mockito.verify;
import static org.mockito.Matchers.eq;

...

Observable model = Class.forName("class name").newInstance();

verify(view, times(1)).update(eq(model), anyObject());

for (Method method : Class.forName("class name").getDeclaredMethods())
{
    method.invoke(model, composeParams(method));
    model.notifyObservers();
    verify(view, atLeastOnce()).update(eq(method), anyObject());
}

Answer 5

You could create matcher to print information on the current method. It's gonna be a bit clunky, but it will work print the method name when the verification fails.

Answer 6

There is org.mockito.internal.verification.Description which delegates to provided VerificationMode, but allows to override verification message.

Answer 7

you can use https://www.javadoc.io/doc/org.mockito/mockito-core/2.2.6/org/mockito/verification/VerificationMode.html#description(java.lang.String)
eg.

verify(mocked,times(1).description("This method is expected to invoke once")).someMethod();