What is the difference between mocking and spying when using Mockito

Question

What would be a use case for a use of a Mockito spy   It seems to me that every spy  use case can be handled with a mock  using callRealMethod   One difference I can see is if you want most method calls to be real  it saves some lines of code to use a mock vs  a spy  Is that it or am I missing the bigger picture

User · Answer

If there is an object with 8 methods and you have a test where you want to call 7 real methods and stub one method you have two options:

Using a mock you would have to set it up by invoking 7 callRealMethod and stub one method
Using a spy you have to set it up by stubbing one method

The official documentation on doCallRealMethod recommends using a spy for partial mocks.

See also javadoc spy(Object) to find out more about partial mocks. Mockito.spy() is a recommended way of creating partial mocks. The reason is it guarantees real methods are called against correctly constructed object because you're responsible for constructing the object passed to spy() method.

User · Answer

Test double types  Mock vs Spy Mock is a bare double object  This object has the same methods signatures but realisation is empty and return default value - 0 and null Spy is a cloned double object  New object is cloned based on a real object but you have a possibility to mock it class A       String foo1             foo2            return  quot RealString 1 quot              String foo2             return  quot RealString 2 quot              void foo3     foo4           void foo4           Test public void testMockA           given     A mockA   Mockito mock A class       Mockito when mockA foo1    thenReturn  quot MockedString quot           when     String result1   mockA foo1        String result2   mockA foo2           then     assertEquals  quot MockedString quot   result1       assertEquals null  result2          Case 2       when     mockA foo3           then     verify mockA  foo3        verify mockA  never    foo4        Test public void testSpyA           given     A spyA   Mockito spy new A          Mockito when spyA foo1    thenReturn  quot MockedString quot           when     String result1   spyA foo1        String result2   spyA foo2           then     assertEquals  quot MockedString quot   result1       assertEquals  quot RealString 2 quot   result2          Case 2       when     spyA foo3           then     verify spyA  foo3        verify spyA  foo4

User · Answer

Spy can be useful when you want to create unit tests for legacy code    I have created a runable example here https   www surasint com mockito-with-spy    I copy some of it here    If you have something like this code   public void transfer   DepositMoneyService depositMoneyService  WithdrawMoneyService withdrawMoneyService                double amount  String fromAccount  String toAccount       withdrawMoneyService withdraw fromAccount amount       depositMoneyService deposit toAccount amount       You may don t need spy because you can just mock DepositMoneyService and WithdrawMoneyService   But with some  legacy code  dependency is in the code like this       public void transfer String fromAccount  String toAccount  double amount            this depositeMoneyService   new DepositMoneyService            this withdrawMoneyService   new WithdrawMoneyService             withdrawMoneyService withdraw fromAccount amount           depositeMoneyService deposit toAccount amount           Yes  you can change to the first code but then API is changed  If this method is being used by many places  you have to change all of them   Alternative is that you can extract the dependency out like this       public void transfer String fromAccount  String toAccount  double amount           this depositeMoneyService   proxyDepositMoneyServiceCreator            this withdrawMoneyService   proxyWithdrawMoneyServiceCreator             withdrawMoneyService withdraw fromAccount amount           depositeMoneyService deposit toAccount amount             DepositMoneyService proxyDepositMoneyServiceCreator             return new DepositMoneyService               WithdrawMoneyService proxyWithdrawMoneyServiceCreator             return new WithdrawMoneyService            Then you can use the spy the inject the dependency like this   DepositMoneyService mockDepositMoneyService   mock DepositMoneyService class           WithdrawMoneyService mockWithdrawMoneyService   mock WithdrawMoneyService class        TransferMoneyService target   spy new TransferMoneyService          doReturn mockDepositMoneyService               when target  proxyDepositMoneyServiceCreator         doReturn mockWithdrawMoneyService               when target  proxyWithdrawMoneyServiceCreator      More detail in the link above

User · Answer

Difference between a Spy and a Mock  When Mockito creates a mock     it does so from the Class of a Type  not from an actual instance  The mock simply creates a bare-bones shell instance of the Class  entirely instrumented to track interactions with it  On the other hand  the spy will wrap an existing instance  It will still behave in the same way as the normal instance     the only difference is that it will also be instrumented to track all the interactions with it   In the following example     we create a mock of the ArrayList class    Test public void whenCreateMock thenCreated         List mockedList   Mockito mock ArrayList class        mockedList add  one        Mockito verify mockedList  add  one         assertEquals 0  mockedList size         As you can see     adding an element into the mocked list doesn   t actually add anything     it just calls the method with no other side-effect  A spy on the other hand will behave differently     it will actually call the real implementation of the add method and add the element to the underlying list    Test public void whenCreateSpy thenCreate         List spyList   Mockito spy new ArrayList         spyList add  one        Mockito verify spyList  add  one         assertEquals 1  spyList size         Here we can surely say that the real internal method of the object was called because when you call the size   method you get the size as 1  but this size   method isn   t been mocked  So where does 1 come from  The internal real size   method is called as size   isn   t mocked  or stubbed  and hence we can say that the entry was added to the real object   Source  http   www baeldung com mockito-spy    self notes

User · Answer

The answer is in the documentation   Real partial mocks  Since 1 8 0  Finally  after many internal debates  amp  discussions on the mailing list  partial mock support was added to Mockito  Previously we considered partial mocks as code smells  However  we found a legitimate use case for partial mocks  Before release 1 8 spy   was not producing real partial mocks and it was confusing for some users  Read more about spying  here or in javadoc for spy Object  method   callRealMethod   was introduced after spy    but spy   was left there of course  to ensure backward compatibility  Otherwise  you re right  all the methods of a spy are real unless stubbed  All the methods of a mock are stubbed unless callRealMethod   is called  In general  I would prefer using callRealMethod    because it doesn t force me to use the doXxx   when   idiom instead of the traditional when   thenXxx

[java] What is the difference between mocking and spying when using Mockito?

Examples related to java

Examples related to testing

Examples related to mocking

Examples related to mockito