How to use findAllMatchingUnverifiedChunks method of org.mockito.internal.invocation.InvocationsFinder class

This is the expected behavior, when you mock something the created instance is a complete mock, so it makes no sense to initialize the fields as behavior is defaulted.

Aside of that, fields can be initialized by a constructor in concrete or abstract classes, as mocks instantiation bypasses the constructor simply because it's a mock, it is even more irrational to initialize them.

Trying to call the real method is usually wrong when using mocks. Instead one should stub the behavior of the mock.

Mockito.when(foo.isNull(Mockito.anyObject())).thenReturn(false);
Assert.assertFalse(foo.isNull("baaba")); // assertion always passing

I don't know your actual use case but maybe you want a partial mock, with a spy. Though that's still considered bad practice as it usually means you need to refactor the code to use composition.

Try adding this annotation to your Test class:

@PowerMockIgnore("javax.management.*")

Worked for me.

It seems that this might be caused because it can't find bytebuddy installed, referring to:

Caused by: java.lang.NoSuchMethodError: net.bytebuddy.dynamic.loading.MultipleParentClassLoader$Builder.appendMostSpecific(Ljava/util/Collection;)Lnet/bytebuddy/dynamic/loading/MultipleParentClassLoader$Builder;

From what I can find online adding bytebuddy to your dependencies might fix this.

    <dependency>
      <groupId>net.bytebuddy</groupId>
      <artifactId>byte-buddy</artifactId>
      <version>XXX</version>
    </dependency>

PowerMockito.doAnswer(new Answer<Void>() {
    /* ... */
}).when(Connector.newConnection(Mockito.any(ConnectorConfig.class)));

Your when is the problem. In normal Mockito, using any doAnswer/doReturn/etc call, you have to place the call you're stubbing outside of the call to when, like so:

Mockito.doAnswer(new Answer<Void>() {
    /* ... */
}).when(yourMock).callVoidMethod();
//            ^^^^^^

PowerMockito further requires that calls to static methods happen in the next statement, like so:

PowerMockito.doAnswer(new Answer<Void>() {
    /* ... */
}).when(Connector.class); Connector.newConnection(/*...*/);
//                    ^^^^^^

Note that from 2009 (~1.3.x) to 2013 (~1.5.x), the docs were actually inconsistent, alluding to a zero-arg when despite all signatures requiring at least a class literal.

Obligatory PSA: It's generally a good idea to avoid mocking types you don't own, though opinions may vary on that one.

You are chaining method calls on your mocked instance:

@Mock
HttpServletRequest mockedRequest = mock(HttpServletRequest.class);

First of all, you do not need to do both, either use the @Mock annotation or the mock method. Like this, you first assign a Mock and then replace this instance with another mock. I recommend the annotation as it adds some context to the mock such as the field's name. This might already cause your NullPointerException as you however never activate the annotations by calling:

MockitoAnnotations.initMocks(this);

as you do not consequently mock all instances with both measures so far. However, even doing so will further result in your exception, so let's move ahead.

Within friendWebService.createFriendRequest(mockedRequest) you call:

User user = (User) request.getSession().getAttribute("user");
User otherUser = (User) request.getSession().getAttribute("profileuser");

where you call a method on two mocks for which you did not specify any behavior. These mocks do by default return null. You need to specify behavior for this such as:

when(request.getSession()).thenReturn(myMockedSession);

before performing this chained call. Based on this, you can then specify how to react to calls on this mocked instance such as returning your user mocks.

You can either use doNothing or doThrow on your mock to mock the behaviour of your mock.

Mockito.doNothing().when(employeeDAO).delete(any());

or

Mockito.doThrow(new RuntimeException()).when(employeeDAO).delete(any());

However, doNothing is not actually needed as this would be the default behaviour for a mock function with a void return type. You may want however to verify that this method was called. For example:

verify(employeeDAO).delete(any());

I suppose that "any" is actually a Mockito.any() method? In that case you can rather use Mockito.matches("regex"). See docs: https://static.javadoc.io/org.mockito/mockito-core/1.9.5/org/mockito/Matchers.html#matches(java.lang.String)

EDIT: It turns out that MockRestServiceServer uses Hamcrest matchers to verify the expectations (methods like requestTo, withSuccess etc.).

There is also a method matchesPattern(java.util.regex.Pattern pattern) in org/hamcrest/Matchers class which is available since Hamcrest 2, and it can be used to solve your problem.

But in your project you probably have the dependency on the older version of Hamcrest (1.3) which is used by, for example, junit 4.12, the latest spring-boot-starter-test-2.13, or, finally, org.mock-server.mockserver-netty.3.10.8 (transitively).

So, you need to:

1. Check the actual version of Hamcrest in your project and (if it's not 2+) update this dependency manually: https://mvnrepository.com/artifact/org.hamcrest/hamcrest/2.1

<dependency>
    <groupId>org.hamcrest</groupId>
    <artifactId>hamcrest</artifactId>
    <version>2.1</version>
    <scope>test</scope>
</dependency>

2. Update your test:

mockServer.expect(requestTo(matchesPattern(".*exact-example-url.com.*")))
    .andExpect(method(HttpMethod.GET))
    .andRespond(withSuccess("response", MediaType.APPLICATION_JSON));

You need to have prepared the class calling the constructor, not the class on which the constructor is called, the following should fix you up:

@PrepareForTest(DummyTarget.class)

For more information check this page.

I got around this by upgrading to the latest version of mockito. Currently it is:

testImplementation "org.mockito:mockito-core:2.25.1"

After that I had some build errors which was resolved by selecting

File->Invalidate Caches / Restart...