CODEWITHSUNDEEP
javaspringmockitospring-testspringmockito
dvelopp
dvelopp

Reputation: 4315

Using @MockBean in tests forces reloading of Application Context

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.

Upvotes: 26

Views: 21172

Answers (5)

AdanhBurg
AdanhBurg

Reputation: 1

Besides the above accepted solution, Since it's will likely break any tests which run after this one which rely on Foo, a better implementation will be to define a @TestConfiguration to wrap up all the beans that need to be mocked:

@TestConfiguration
public class TestConfig {

    @Bean
    @Primary
    public StoreService storeService() {
        return Mockito.mock(StoreService.class);
    }

}

Then in your base test class (BaseITCase) you can load the test configuration which will add our mocked beans to the context:

@WebMvcTest
@ContextConfiguration(
        classes = {TestConfig.class}
)
class BaseTest {

}

and just like that we can inject and use our mocked services and share them across the test classes and only one context will be used for all the tests without been marked as dirty.

Upvotes: 0

Jawad
Jawad

Reputation: 337

I ran into this and I think instead of using @Primary, the better solution is to use Spring's "Bean-Overriding" feature.

(This works specially well if you are using an actual web server when running the tests i.e. @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT), which is the case for me):

Do the following:

  1. Create a separate application properties file for unit tests and annotate your unit test class as follows to load it:

    @TestPropertySource(locations = "classpath:application-unittest.properties")

  2. Set this property to true in the above application-unittest.properties file:

    spring.main.allow-bean-definition-overriding=true

  3. Make sure you dont have any annotations that modify the context after it is created (such as @AutoConfigureJsonTesters). Otherwise the context will get recreated after each test ((or throw IllegalStateException, depending on the whether your @TestInstance setting is TestInstance.Lifecycle.PER_METHOD or PER_CLASS). I dont know about a full list of such annotations, u can do trial and error to find out.

  4. Remove all @MockBean annotations and define all such beans inside an @Configuration class for your unit test class for example:

    @TestConfiguration public class UnitTestConfiguration {

    @Bean public MyService myService() { return Mockito.mock(MockService.class, MockReset.withSettings(MockReset.NONE)); }

    }

HERE YOU NEED TO MAKE SURE THE NAME OF THE METHOD (myService in this case) MATCHES THE NAME OF THE REAL BEAN when its created in the Spring context. This is necessary to use bean overriding.

So for example if you have autowired a real bean then by default Spring uses the class name of the bean in camel case as the bean name when defining it in the Spring-Context. So to override such a bean your method name should be the same as the name of the class but in camel case.

  1. Do an @Import in your unit test class to import the above configuration:

    @Import(UnitTestConfiguration.class)

Now you can just @Autowire the mocked beans inside your unit test class and apply stubbing (Mockito.when etc) as needed.

Upvotes: 2

Peter Borbas
Peter Borbas

Reputation: 178

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

  1. 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);
   }

  2. 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;

  3. 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); }

  4. 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);

Upvotes: 1

Antoine Meyer
Antoine Meyer

Reputation: 372

@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.

Upvotes: 9

Daniel Camarasa
Daniel Camarasa

Reputation: 385

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.

Upvotes: 26

Related Questions