Mockito: Trying to spy on method is calling the original method

Question

I'm using Mockito 1.9.0. I want mock the behaviour for a single method of a class in a JUnit test, so I have

final MyClass myClassSpy = Mockito.spy(myInstance);
Mockito.when(myClassSpy.method1()).thenReturn(myResults);

The problem is, in the second line, myClassSpy.method1() is actually getting called, resulting in an exception. The only reason I'm using mocks is so that later, whenever myClassSpy.method1() is called, the real method won't be called and the myResults object will be returned.

MyClass is an interface and myInstance is an implementation of that, if that matters.

What do I need to do to correct this spying behaviour?

Lawrencelawrencium

Take a look at this: https://mcmap.net/q/75240/-mockito-difference-between-doreturn-and-when – Inoperative

Answer 1

Let me quote the official documentation:

Important gotcha on spying real objects!

Sometimes it's impossible to use when(Object) for stubbing spies. Example:

List list = new LinkedList();
List spy = spy(list);

// Impossible: real method is called so spy.get(0) throws IndexOutOfBoundsException (the list is yet empty)
when(spy.get(0)).thenReturn("foo");

// You have to use doReturn() for stubbing
doReturn("foo").when(spy).get(0);

In your case it goes something like:

doReturn(resultsIWant).when(myClassSpy).method1();

Ileenileitis

What if I use this method and my original one is STILL getting called? Could there be problem with parameters I pass? Here is the whole test: pastebin.com/ZieY790P send method is being called – Massa

@EvgeniPetrov if your original method is still being called it's probably because your original method is final. Mockito doesn't mock final methods, and cannot warn you about the mocking of final methods. – Taught

is this also possible for doThrow()? – Koto

is the final Method rule also apply to static methods , my static methods are getting called even when I use doReturn().when().myMethod() – Xiaoximena

Mockito can't mock static methods. #4482815 – Making

yes, unfortunately static methods are unmockable and "un-spy-able". What I do to deal with static methods is to wrap a method around the static call and use a doNothing or doReturn on that method. With singletons or scala objects I move the meat of the logic to an abstract class and that gives me the ability to have an alternate test class impl of the object that I can create a spy on. – Scaramouch

And what if the NOT final and NOT static method is still getting called? – Leonoraleonore

I had this issue when tried to spy on a static method and mock it, what I did was: PowerMockito.spy(ClassToMock.class); PowerMockito.doAnswer(i -> getValueToReturn()).when(ClassToMock.class, "methodToMock"); – Spiegelman

Wasted an entire day trying to figure out why my real method was being called when trying to setup a stub. See @MarcG comment. If the method you're trying to mock is marked final, you'll get NO error, NO warning, NOTHING. It just won't work and you're out of luck unless you're lucky enough to stumble on this comment or MarkG's... There's several reasons mockito will silently fail, but I'm betting loads of people show up here because their method is final and mockito fails silently. – Pillage

Why is the when impossible in this example? – Peacemaker

For everyone who got to this point, tried everything and Mokito still calling original method - look below for @ejaenv answer. – Obstructionist

as @TimurSadykov said, this answer may solve your problem if you got this far! – Tapia

Another possibility for why it might still call the real method is if you have an overloaded method and the parameters used when mocking don't match the overload you're trying to test. – Alexandros

I was missing @ExtendWith(MockitoExtension.class) which even after doing the above gave me an error argument passed to when is not a mock. – Dallapiccola

I got stuck at this point and never realized. Thanks it worked for me – Unnatural

Answer 2

In my case, using Mockito 2.0, I had to change all the any() parameters to nullable() in order to stub the real call.

Embed

Don't let that 321 voted top answer get you down, this solved my problem :) I've been struggling with this for a couple hours! – Reamer

This was the answer for me. To make it even easier for those that follow when mocking your method the syntax is: foo = Mockito.spy(foo); Mockito.doReturn(someValue).when(foo).methodToPrevent(nullable(ArgumentType.class)); – Deliciadelicious

With Mockito 2.23.4 I can confirm this is not necessary, it works fine with any and eq matchers. – Geesey

Tried three different approached on 2.23.4 lib version: any(), eq() and nullable(). Only the later worked – Pogy

Hi, your solution really nice and worked for me as well. Thanks – Dominican

Im using mockito-core version 3.4.0 and making it nullable() worked. Can someone explain why any() doesnt work? – Westbound

I had to change anyString() to any(). Mockito currently (3.4.0) stopped allowing the more specific matchers to match null, just like it stopped allowing any() to work with primitives because it now passes null. Crazy stuff. – Suttee

But in the case of this post, there are no parameters – Cony

Any solution for the case when there are not parameters? It still doesn't work for me. My method is not final and not static – Redemption

This helped when others didn't. Upvoted. – Tombolo

This answer deserves its own question :) – Praiseworthy

Answer 3

My case was different from the accepted answer. I was trying to mock a package-private method for an instance that did not live in that package

package common;

public class Animal {
  void packageProtected();
}

package instances;

class Dog extends Animal { }

and the test classes

package common;

public abstract class AnimalTest<T extends Animal> {
  @Before
  setup(){
    doNothing().when(getInstance()).packageProtected();
  }

  abstract T getInstance();
}

package instances;

class DogTest extends AnimalTest<Dog> {
  Dog getInstance(){
    return spy(new Dog());
  }

  @Test
  public void myTest(){}
}

The compilation is correct, but when it tries to setup the test, it invokes the real method instead.

Declaring the method protected or public fixes the issue, tho it's not a clean solution.

Collusive

I ran into a similar issue, but the test and package-private method were in the same package. I think perhaps Mockito has issues with package-private methods in general. – Lawrencelawrencium

Is there any known fix for this now ? I am facing similar scenario as @Collusive . – Presumably

Answer 4

The answer by Tomasz Nurkiewicz appears not to tell the whole story!

NB Mockito version: 1.10.19.

I am very much a Mockito newb, so can't explain the following behaviour: if there's an expert out there who can improve this answer, please feel free.

The method in question here, getContentStringValue, is NOT final and NOT static.

This line does call the original method getContentStringValue:

doReturn( "dummy" ).when( im ).getContentStringValue( anyInt(), isA( ScoreDoc.class ));

This line does not call the original method getContentStringValue:

doReturn( "dummy" ).when( im ).getContentStringValue( anyInt(), any( ScoreDoc.class ));

For reasons which I can't answer, using isA() causes the intended (?) "do not call method" behaviour of doReturn to fail.

Let's look at the method signatures involved here: they are both static methods of Matchers. Both are said by the Javadoc to return null, which is a little difficult to get your head around in itself. Presumably the Class object passed as the parameter is examined but the result either never calculated or discarded. Given that null can stand for any class and that you are hoping for the mocked method not to be called, couldn't the signatures of isA( ... ) and any( ... ) just return null rather than a generic parameter* <T>?

Anyway:

public static <T> T isA(java.lang.Class<T> clazz)

public static <T> T any(java.lang.Class<T> clazz)

The API documentation does not give any clue about this. It also seems to say the need for such "do not call method" behaviour is "very rare". Personally I use this technique all the time: typically I find that mocking involves a few lines which "set the scene" ... followed by calling a method which then "plays out" the scene in the mock context which you have staged... and while you are setting up the scenery and the props the last thing you want is for the actors to enter stage left and start acting their hearts out...

But this is way beyond my pay grade... I invite explanations from any passing Mockito high priests...

* is "generic parameter" the right term?

Nightshade

I don't know if this adds clarity or further confuses the matter, but the difference between isA() and any() is that isA actually does type checking, whereas any() family of methods was created simply to avoid type casting of the argument. – Chantal

@KevinWelker Thanks. And indeed the method names are not lacking in a certain self-explanatory quality. I do however, and however mildly, take issue with the genius Mockito designers for not documenting adequately. No doubt I need to read yet another book on Mockito. PS actually there seem to be very few resources to teach "intermediate Mockito"! – Nightshade

The history is that the anyXX methods were created first as a way to deal with typecasting only. Then when it was suggested they add the argument checking, they didn't want to break users of the existing API, so they created the isA() family. Knowing that the any() methods should have done the type checking all along, they delayed changing those until they introduced other breaking changes in the Mockito 2.X overhaul (which I have not tried yet). In 2.x+, anyX() methods are aliases for the isA() methods. – Chantal

Thank you. This is a pivotal answer for those of us doing several library updates at the same time, because code that used to run is suddenly and silently failing. – Pibroch

Answer 5

One more possible scenario which may causing issues with spies is when you're testing spring beans (with spring test framework) or some other framework that is proxing your objects during test.

Example

@Autowired
private MonitoringDocumentsRepository repository

void test(){
    repository = Mockito.spy(repository)
    Mockito.doReturn(docs1, docs2)
            .when(repository).findMonitoringDocuments(Mockito.nullable(MonitoringDocumentSearchRequest.class));
}

In above code both Spring and Mockito will try to proxy your MonitoringDocumentsRepository object, but Spring will be first, which will cause real call of findMonitoringDocuments method. If we debug our code just after putting a spy on repository object it will look like this inside debugger:

repository = MonitoringDocumentsRepository$$EnhancerBySpringCGLIB$$MockitoMock$

@SpyBean to the rescue

If instead @Autowired annotation we use @SpyBean annotation, we will solve above problem, the SpyBean annotation will also inject repository object but it will be firstly proxied by Mockito and will look like this inside debugger

repository = MonitoringDocumentsRepository$$MockitoMock$$EnhancerBySpringCGLIB$

and here is the code:

@SpyBean
private MonitoringDocumentsRepository repository

void test(){
    Mockito.doReturn(docs1, docs2)
            .when(repository).findMonitoringDocuments(Mockito.nullable(MonitoringDocumentSearchRequest.class));
}

Ribband

@SpyBean is available only in Spring Boot: is there any similar workaround for Spring? – Literati

Answer 6

Important gotcha on spying real objects

When stubbing a method using spies , please use doReturn() family of methods.

when(Object) would result in calling the actual method that can throw exceptions.

List spy = spy(new LinkedList());

//Incorrect , spy.get() will throw IndexOutOfBoundsException   
 when(spy.get(0)).thenReturn("foo");

//You have to use doReturn() for stubbing    
doReturn("foo").when(spy).get(0);

Merge

Boolean cannot be returned by toString() toString() should return String – Assignment

Answer 7

I've found yet another reason for spy to call the original method.

Someone had the idea to mock a final class, and found about MockMaker:

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

Source: https://github.com/mockito/mockito/wiki/What%27s-new-in-Mockito-2#mock-the-unmockable-opt-in-mocking-of-final-classesmethods

After I merged and brought that file to my machine, my tests failed.

I just had to remove the line (or the file), and spy() worked.

Anachronous

this was the reason in my case, I was trying to mock a final method but it kept calling the real one without a clear error message which was confusing. – Amu

Answer 8

One way to make sure a method from a class is not called is to override the method with a dummy.

    WebFormCreatorActivity activity = spy(new WebFormCreatorActivity(clientFactory) {//spy(new WebFormCreatorActivity(clientFactory));
            @Override
            public void select(TreeItem i) {
                log.debug("SELECT");
            };
        });

Croak

Answer 9

As mentioned in some of the comments, my method was "static" (though being called on by an instance of the class)

public class A {
  static void myMethod() {...}
}
A instance = spy(new A());
verify(instance).myMethod(); // still calls the original method because it's static

Work around was make an instance method or upgrade Mockito to a newer version with some config: https://mcmap.net/q/73871/-mocking-static-methods-with-mockito

Southwestward

Answer 10

In my case, using any(Myclass.class) instead of any() solved my problem

Transfix

Answer 11

Bit late to the party but above solutions did not work for me , so sharing my 0.02$

Mokcito version: 1.10.19

MyClass.java

private int handleAction(List<String> argList, String action)

Test.java

MyClass spy = PowerMockito.spy(new MyClass());

Following did NOT work for me (actual method was being called):

1.

doReturn(0).when(spy , "handleAction", ListUtils.EMPTY_LIST, new String());

2.

doReturn(0).when(spy , "handleAction", any(), anyString());

3.

doReturn(0).when(spy , "handleAction", null, null);

Following WORKED:

doReturn(0).when(spy , "handleAction", any(List.class), anyString());

Peadar