Calling real method using Mockito

Question

I am using JDK 11 and spring boot. I am implementing a rest API and have 3 layers:

• controller
• service layer
• data access layer

I had classes against interfaces at the data-access-layer and did not have any interface at the service layer.

I wrote integration tests using MockMvc, Mockito, etc to exercise the whole path for each point, exposed by the controller. This was not a problem until I tried to introduce the interface at the service layer.

Initially, I mocked only repositories/Daos. So the class structure looked like:

    public interface ClientRepo{
    ......
    }

    public class ClientRepoImpl implements ClientRepo{
    ......
    }

Mocked the returned data as:

    @MockBean 
    private ClientRepo client;

    ....
    Mockito.when(client.isExistFkUnitId(Mockito.any(UUID.class))).thenReturn(false); 

Everything was fine so far.

Now I have introduced interface at the service layer as :

    public interface ClientService{
    ......
    }

    public class ClientServiceImpl implements ClientService{
    ......
    }

And tried ( Trying to call actual service method):

    @MockBean 
    private ClientService clientService;

    ....
    Mockito.when(clientService.isExistFkUnitId(Mockito.any())).thenCallRealMethod();

But getting nothing but null all the time.

Is there a way to make the real method call keeping the interface?

Answer 1

I think you want to use @Spy annotation instead of @Mock annotation on the field where you want to call the real method. I don't happen to have an example to verify this though. https://javadoc.io/doc/org.mockito/mockito-core/2.21.0/org/mockito/Spy.html

Then you can do doCallRealMethod().when(clientService.isExistFkUnitId(Mockito.any())). Because with a spy object you call doReturn/when instead of when/doReturn. https://javadoc.io/doc/org.mockito/mockito-core/2.21.0/org/mockito/Mockito.html#do_family_methods_stubs

Answer 2

Well, there is no "real" method to call. (Ignoring the fact that default methods in interfaces are a thing nowadays)

Generally, unit tests should be written for the target class in an isolated fashion. Like this, you are always "testing" the "isExistFkUnitId" method as well. You could set the mock up for specific values:

Mockito.when(clientService.isExistFkUnitId("valueA").thenReturn("answerA");
Mockito.when(clientService.isExistFkUnitId("valueB").thenReturn("answerB");

Anyways... to respond to your actual question:

If possible, you can instantiate the implementation in a way that the desired method is working and call it through the mock:

ClientServiceImpl clientServiceImpl = new ClientServiceImpl(...);
// spaghetti code only for demonstration purposes ;)
Mockito.when(clientService.isExistFkUnitId(Mockito.any())).then(i -> clientServiceImpl.isExistFkUnitId((String) i.getArguments()[0]));

POC test:

@Test
public void testit() {
    Myclass myclass = new Myclass();
    Myinterface mock = Mockito.mock(Myinterface.class);
    Mockito.when(mock.myMethod(Mockito.any())).then(i -> myclass.myMethod((String) i.getArguments()[0]));

    assertThat(mock.myMethod(" works")).isEqualTo("yeehaa works");
}

public interface Myinterface {
    String myMethod(String params);
}

public static class Myclass implements Myinterface {
    @Override
    public String myMethod(String params) {
        return "yeehaa" + params;
    }
}

Not exactly a beautiful solution, but if there is no way around it, it should work.