Mockito Stubbing not working after an exception is stubbed

Question

So, I am trying to unit test a class in various scenarios. We use JUnit V 4.
I have a setUp method wherein i reStub the mock to return an expected mock Value. I have 4 tests : test1-test4. test1,test2 work fine with the expected mocked value configured in perTestSetup method.

Test t3 needs MockClass to throw an exception, so i configure it seperately in t3. Now t3 works fine as the mock throws the exception as expected.

But when perTestSetup tries to reset the mock to return mockResult before running test4, it fails and throws the same Runtime exception configured in t4. I also tried reset() before mocking in perTestSetup(). But that too fails similarly.

What am i missing here?

@Before
public void perTestSetup(){ 
    when(MockClass.functionCall(...)).thenReturn(mockResult);
}

@Test
public void test1(){
}

@Test
public void test2(){
}

@Test
public void test3(){
    when(MockClass.functionCall(...)).thenThrow(new RuntimeExcption());
    ...
}

@Test
public void test4(){
}

Answer 1

Your perTestSetup() method isn't doing what you think it is doing. The @Before annotation means the test environment will run this method once, before doing any of the tests, rather than once per test. Before I finished reading your question, I was actually itching to advise you to rename this method to simply setup(), as that would be a more accurate description.

Options:

1. Change the annotation to @BeforeEach, which would then change the behaviour to do what you think it should currently be doing. However, this would be inefficient as in the second two tests you will be defining behaviour and then immediately redefining it.

2. What do the parameters look like in your functionCall(...)? It may be possible to define two separate behaviours in your single @Before setup() method, i.e.

when(MockClass.functionCall(good values)).thenReturn(mockResult);
when(MockClass.functionCall(bad values)).thenThrow(new RuntimeException());

In each test, call functionCall() with the relevant values for that that particular test.

3. If the parameters in functionCall() do not readily accommodate the previous approach, consider making two separate instantiations of MockClass, something like

MockClass successfulMockClass = new mock(MockClass.class);
when(successfulMockClass()).thenReturn(mockResult);
MockClass unsuccessfulMockClass = new mock(MockClass.class);
when(unsuccessfulMockClass()).thenThrow(new RuntimeException());

In your tests, call on the relevant mocked object depending on what input you are testing against.

Without being able to see the details of your class, I suspect the second option is what I would go for. It may be worth trying all three to see which feels most intuitive for you, though.