How to use getThrowable method of org.mockito.internal.handler.NotifiedMethodInvocationReport class

Having such interface:

interface Foo {
    void method(String s);
}

One idea is to use regular expression matching:

final Foo mock = mock(Foo.class);
mock.method("abc");
verify(mock).method(matches(".{3}"));

Unfortunately there is no built-in matcher for string length (there should be!), but it's easy to write custom one:

private static String hasSize(final int size) {
    return argThat(new ArgumentMatcher<String>() {
        @Override
        public boolean matches(Object argument) {
            return argument.toString().length() == size;
        }
    });
}

Now simply call static method:

verify(mock).method(hasSize(4));

When you create a mock object

mockResponse = mock(HttpServletResponse.class);

by default, all its methods that have a reference type return type (minus a few special cases) return null.

So the return value of getOutputStream() in this snippet

ServletOutputStream outputStream = response.getOutputStream();

is null.

You need to set expectations and specify a return value.

when(mockResponse.getOutputStream().thenReturn(/* the value to return when that method is invoked */);

This is called stubbing.

Iterator mockIterator = mock(Iterator.class);
doCallRealMethod().when(fruits).forEach(any(Consumer.class));
when(fruits.iterator()).thenReturn(mockIterator);
when(mockIterator.hasNext()).thenReturn(true, false);
when(mockIterator.next()).thenReturn(mockObject);

Mockito 2 now supports final classes and methods!

But for now that's an "incubating" feature. It requires some steps to activate it which are described in What's New in Mockito 2:

Mocking of final classes and methods is an incubating, opt-in feature. It uses a combination of Java agent instrumentation and subclassing in order to enable mockability of these types. As this works differently to our current mechanism and this one has different limitations and as we want to gather experience and user feedback, this feature had to be explicitly activated to be available ; it can be done via the mockito extension mechanism by creating the file src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker containing a single line:

mock-maker-inline

After you created this file, Mockito will automatically use this new engine and one can do :

 final class FinalClass {
   final String finalMethod() { return "something"; }
 }

 FinalClass concrete = new FinalClass(); 

 FinalClass mock = mock(FinalClass.class);
 given(mock.finalMethod()).willReturn("not anymore");

 assertThat(mock.finalMethod()).isNotEqualTo(concrete.finalMethod());

In subsequent milestones, the team will bring a programmatic way of using this feature. We will identify and provide support for all unmockable scenarios. Stay tuned and please let us know what you think of this feature!

Make sure the hamcrest jar is higher on the import order than your JUnit jar.

JUnit comes with its own org.hamcrest.Matcher class that is probably being used instead.

You can also download and use the junit-dep-4.10.jar instead which is JUnit without the hamcrest classes.

mockito also has the hamcrest classes in it as well, so you may need to move\reorder it as well

You should PrepareForTest the Foo class:

@PrepareForTest(Foo.class)
@RunWith(PowerMockRunner.class)
public class ...

I'm not sure how spy behaves for static methods, so I prefer to use mockStatic:

PowerMockito.mockStatic(LocalDate.class);
when(LocalDate.now())....

To make the code more testable and don't depend on mocking static methods, you could also refactor your code to use a java.time.Clock:

public class Foo {

    private Clock clock;

    public Foo() {
        // use the system's default clock
        this(Clock.systemDefaultZone());
    }

    public Foo(Clock clock) {
        // use a custom clock
        this.clock = clock;
    }

    public LocalDate getRightNow() {
        final LocalDate rightNow = LocalDate.now(this.clock);
        return rightNow;
    }
}

If you don't specify a Clock, it'll use the system's default (exactly what the now() method does when called without parameters).

Then, in your test, you create a Clock that always return the same date and pass it to the Foo class. In this case, you won't need all the PowerMockito stuff:

public class UserTest {

    @Test
    public void nowShouldReturnSameYear() throws Exception {
        LocalDate parse = LocalDate.parse("2008-04-04");
        // create a fixed clock (it always return the same date, using the system's default timezone)
        ZoneId zone = ZoneId.systemDefault();
        Clock clock = Clock.fixed(parse.atStartOfDay(zone).toInstant(), zone);

        Foo foo = new Foo(clock);
        assertEquals(parse.getYear(), foo.getRightNow().getYear());
    }
}

This is indeed a limitation of Mockito, and it is referenced in their FAQ:

Can I thenReturn() an inlined mock()?

Unfortunately you cannot do this:

when(m.foo()).thenReturn(mock(Foo.class));
//                         ^

The reason is that detecting unfinished stubbing wouldn't work if we allow above construct. We consider is as a 'trade off' of framework validation (see also previous FAQ entry). However you can slightly change the code to make it working:

//extract local variable and start smiling:
Foo foo = mock(Foo.class);
when(m.foo()).thenReturn(foo);

The workaround, as mentioned, is to store the desired returned value in a local variable, like you have done.

The way I understand it is that Mockito validates the usage you make of it every time you call its methods. When another method is called during an on-going stubbing process, you are breaking its validation process.

Mockito mock works when we mock the objects loosely.

Here is the change i have made to make it work:

when(controlWfDefTypeService.getDqCntlWfDefnTypCd(any(DqCntlWfDefn.class))
    .thenReturn(dqCntlWfDefnTyp);

Instead of passing the object of the Mock class, I passed the class with the Matcher any() and it works.

Take a look at the Mockito API docs. As the linked document mentions (Point # 12) you can use any of the doThrow(),doAnswer(),doNothing(),doReturn() family of methods from Mockito framework to mock void methods.

For example,

Mockito.doThrow(new Exception()).when(instance).methodName();

or if you want to combine it with follow-up behavior,

Mockito.doThrow(new Exception()).doNothing().when(instance).methodName();

Presuming that you are looking at mocking the setter setState(String s) in the class World below is the code uses doAnswer method to mock the setState.

World mockWorld = mock(World.class); 
doAnswer(new Answer<Void>() {
    public Void answer(InvocationOnMock invocation) {
      Object[] args = invocation.getArguments();
      System.out.println("called with arguments: " + Arrays.toString(args));
      return null;
    }
}).when(mockWorld).setState(anyString());