Using @MockBean in tests forces reloading of Application Context

Question

I have several integration tests running on Spring Framework that extend the base class called BaseITCase.
Like this:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {AppCacheConfiguration.class, TestConfiguration.class}, loader = SpringBootContextLoader.class)
@Transactional
@WebMvcTest
public abstract class BaseITCase{...}
...
public class UserControllerTest extends BaseITCase {...}

The problem is that one of the test has several declarations of: @MockBean inside of it and the moment this test executed, Spring recreates context and the tests that follows this one sometimes use wrong beans(from the context created exactly for the test with @MockBean). I found out about that just by checking that beans have different hashcodes.

It becomes really critical when I use @EventListener. Because listeners for wrong context(context of the test class that has already finished execution) are invoked and I have wrong beans there.

Is there any workaround for that?

I tried to move all @MockBean declarations to basic class and it worked fine because new context is not created. But, it makes basic class too heavy. Also, I tried to make a dirty context for this test, but then the next test fails with message that context has already been closed.

By mistake a posted an answer for another question in your post. Sorry! I deleted it. — Perimosh, Feb 22 '18 at 20:49

score 26 · Accepted Answer · answered Feb 26 '18 at 11:57

The reason is that the spring configuration for the test having the @MockBean is different from the rest of the tests, so the spring framework cannot cache previously used context and needs to load it again. Here you can find a more detailed explanation: https://github.com/spring-projects/spring-boot/issues/10015

As you said, if you move the mock bean to the parent class the context doesn't get reloaded, which makes sense as the bean configuration remains the same.

A possible workaround is defining your mock bean as a simple mock and injecting it manually where is required.

For instance, UserController has a dependency on Foo:

public class UserControllerTest extends BaseITCase {

    private Foo foo = Mockito.mock(Foo.class);

    @Autowired
    private UserController userController;

    @Before
    public void setUp() {
        super.setup();

        this.userController.setFoo(foo);
    }
}

@Component
public class UserController {

    private Foo foo;

    @Autowired
    public void setFoo(final Foo foo) {
        this.foo = foo;
    }
}

Hope this helps.

I wouldn't recommend this approach since it "dirties" the application context. Your implementation above will likely break any tests which run after this one which rely on Foo. At bare minimum you should store the initial Foo in @Before then restore it back to it's original state in @ After. — lance-java, Aug 19 '22 at 15:36

score 7 · Answer 2 · answered Mar 18 '21 at 00:35

@MockBean may cause the context to reload as explained in the previous answer.

As an alternative and if you're using spring boot 2.2+, you can use @MockInBean instead of @MockBean. It keeps your context clean and does not require your context to get reloaded.

@SpringBootTest
public class UserControllerTest extends BaseITCase {

    @MockInBean(UserController.class)
    private Foo foo;

    @Autowired
    private UserController userController;

    @Test
    public void test() {
        userController.doSomething();
        Mockito.verify(foo).hasDoneSomething();
    }
}

@Component
public class UserController {

    @Autowired
    private Foo foo;

}

disclaimer: I created this lib for this exact purpose: mock beans in spring beans and avoid lengthy context recreation.

Thanks @antoine-meyer for this project, it worked for me. The only thing that I'll add is that if you want spy on UserController, you can add `@SpyBean private UserController userController` in the BaseITCase and it'll work too — Thiago Cavalcanti, Feb 09 '23 at 22:00

score 0 · Answer 3 · answered May 25 '23 at 11:10

Besides the above solutions, if you want to inject them everywhere, you can

Create a configuration in your test packages and define the mock beans as @Primary so they'll be injected instead of the real ones.

@Configuration
 public class MockClientConfiguration {

   @Bean
   @Primary
   public ApiClient mockApiClient() {
     return mock(ApiClient.class);
   }

In your base test class @Autowire, since they are @Primary, you'll get the mocks. Notice, they are protected

@SpringBootTest public class BaseIntTest {
```
   @Autowired
   protected ApiClient mockApiClient;
```
Then in your base test class you can reset the mocks before each run and set default behaviour:

@BeforeEach public void setup() { Mockito.reset(mockApiClient); Mockito.when(mockApiClient.something(USER_ID)).thenReturn(true); }

From you test classes access the mocks:

public class MyTest extends BaseIntTest {
   @Test
   public void importantTestCase() {
       Mockito.reset(mockApiClient);
       Mockito.when(mockApiClient.something(USER_ID)).thenReturn(false);

Using @MockBean in tests forces reloading of Application Context

3 Answers3

Linked