mockito : how to unmock a method?

I have a JUnit class with different methods to perform different tests.

I use Mockito to create a spy on real instance, and then override some method which is not relevant to the actual test I perform.

Is there a way, just for the sake of cleaning up after me in case some other tests that run after my tests also use the same instances and might execute a mocked method they didn't ask to mock, to un-mock a method?

say I have a spy object called 'wareHouseSpy'

say I overriden the method isSomethingMissing :

doReturn(false).when(wareHouseSpy).isSomethingMissing()

What will be the right way to un-override, and bring things back to normal on the spy i.e make the next invokation of isSomethingMissing to run the real method?

something like

doReturn(Mockito.RETURN_REAL_METHOD).when(wareHouseSpy).isSomethingSpy()

or maybe

Mockito.unmock(wareHouseSpy)

Who knows? I couldn't find nothing in that area

Thanks!

Assaf

I think

Mockito.reset(wareHouseSpy)

would do it.

Let's say most of your tests use the stubbed response. Then you would have a setUp() method that looks like this:

@Before
public void setUp() {
  wareHouseSpy = spy(realWarehouse);
  doReturn(false).when(wareHouseSpy).isSomethingMissing();
}

Now let's say you want to undo the stubbed response and use the real implementation in one test:

@Test
public void isSomethingMissing_useRealImplementation() {
  // Setup
  when(wareHouseSpy.isSomethingMissing()).thenCallRealMethod();

  // Test - Uses real implementation
  boolean result = wareHouseSpy.isSomethingMissing();
}

It depends whether you are testing with TestNG or JUnit.

• JUnit creates a new instance of itself for each test method. You basically don't have to worry about reseting mocks.
• With TestNG, you have to reset the mock(s) with Mockito.reset(mockA, mockB, ...) in either an @BeforeMethod or an @AfterMethod

The "normal" way is to re-instantiate things in your "setUp" method. However, if you have a real object that is expensive to construct for some reason, you could do something like this:

public class MyTests {

  private static MyBigWarehouse realWarehouse = new MyBigWarehouse();
  private MyBigWarehouse warehouseSpy;

  @Before
  public void setUp() {
    warehouseSpy = spy(realWarehouse); // same real object - brand new spy!
    doReturn(false).when(wareHouseSpy).isSomethingMissing();
  }

  @Test
  ...

  @Test
  ...
 
  @Test
  ...
}

Maybe I am not following but when you have a real object real:

Object mySpy = spy(real);

Then to "unspy" mySpy... just use real.

Addressing this piece specifically:

> Is there a way, just for the sake of cleaning up after me in case some other tests that run after my tests also use the same instances and might execute a mocked method they didn't ask to mock, to un-mock a method?

If you are using JUnit, the cleanest way to do this is to use @Before and @After (other frameworks have equivalents) and recreate the instance and the spy so that no test depends on or is impacted by whatever you have done on any other test. Then you can do the test-specific configuration of the spy/mock inside of each test. If for some reason you don't want to recreate the object, you can recreate the spy. Either way, everyone starts with a fresh spy each time.

As per the documentation, we have

reset(mock);
//at this point the mock forgot any interactions & stubbing

The documentation specifies further

> Normally, you don't need to reset your mocks, just create new mocks > for each test method. Instead of #reset() please consider writing > simple, small and focused test methods over lengthy, over-specified > tests.

Here's an example from their github repo which tests this behavior and uses it:

@Test
public void shouldRemoveAllInteractions() throws Exception {
        mock.simpleMethod(1);
        reset(mock);
        verifyZeroInteractions(mock);
}

reference : ResetTest.java