SpringBoot replacing beans in tests

Question

Is there a common way to replace beans for tests? And is it possible to implement two and more applications in same project?

I attempt to get next configuration:

I have a main SpringBoot application with the configured beans:

package org.application.app;

@SpringBootApplication
public class Application {

  public static void main(String[] args) {
    SpringApplication.run(Application.class, args);
  }

  @Bean
  public Service1 service1() {
    return new Service1();
  }

  @Bean
  public Service2 service2() {
    return new Service2();
  }
}

In tests, I need to change the configuration of one of the beans, so I need to replace the bean. But I need to keep the rest configuraiton from the main application:

package org.application.app;

// @SpringBootTest // will give BeanDefinitionOverrideException
@SpringBootTest(properties = {"spring.main.allow-bean-definition-overriding=true"})
@RunWith(SpringRunner.class)
public class ApplicationTest {

  @Test
  public void test() {

  }

  @Configuration
  @Import(Application.class)
  public static class Config {

    @Bean
    public Service2 service2() {
      return new Service2();
    }
  }
}

So, the first question: how to avoid the allow-bean-definition-overriding? Is there a common way? I tried the different bean's names and @Primary, but if I need more then two alternate beans to define?

Also I want to implement some small demo-applications for testing puproses together with the main application. Demo-applications are defined in test source tree, but in the own package. They needs to use configuration from main application and define own beans, like the tests do it:

package org.application.demo;

@SpringBootApplication
@Import(Application.class)
public class ApplicationDemo {

  public static void main(String[] args) {
    SpringApplication.run(ApplicationDemo.class, args);
  }
}

But this problem has not been solved at all. If I run ApplicationDemo, I got the exception about ApplicationTest$Config:

The bean 'service2', defined in class path resource [org/application/app/ApplicationTest$Config.class], could not be registered. A bean with that name has already been defined in class path resource [org/application/app/Application.class] and overriding is disabled.

How to exclude all *Test classes from ComponentScan in ApplicationDemo case?

I am already very confused how to tie all these situations and at the same time avoid implicit overriding of beans...

Update

I will clarify the question. There is a main application configuration. The test configuration inherits from the main configuration and overrides some beans. The specific test configuration inherits from the main test configuration and also overrides some beans. Is there a best practices to implement such a pattern?

Using profiles seems to be the wrong way for this pattern.

My best solution is the following:

Application:

package beans.orig.bean;

// The bean should be manually configured
public class MyBean {

  @Autowired
  public MyBean bean1;
  
  public String value;

  public MyBean(String value) {
    this.value = value;
  }
}

// The component will be loaded by @ComponentScan
@Component
public class MyComponent {

  @Autowired
  public MyBean bean2;
}

package beans.orig;

@SpringBootApplication
public class Application {

  public static void main(String[] args) {
    ApplicationContext ctx = SpringApplication.run(Application.class, args);
    MyBean bean2 = (MyBean) ctx.getBean("bean2");
    if (!bean2.value.equals("bean2")) {
      throw new RuntimeException();
    }
    System.out.println("OK");
  }
}

// Main application configuration.
// It could be inside the Application class, but then @Import(Application.class)
// in tests will trigger @ComponentScan, what to avoid sometimes.
@Configuration
public class ApplicationConfig {

  @Bean
  public MyBean bean1() {
    return new MyBean("bean1");
  }

  @Bean
  public MyBean bean2() {
    return new MyBean("bean2");
  }
}

And tests:

package beans.orig;

// Main test configuration.
// It uses main config with some overridden beans.
@Configuration
@Import(Application.class) // to allow @ComponentScan and so on...
public class TestConfig {

  // Override bean2
  @Bean
  public MyBean bean2() {
    return new MyBean("bean2 from TestConfig");
  }
}

// Use virgin main configuration
@SpringBootTest
@RunWith(SpringRunner.class)
public class Test1 {

  @Autowired
  MyComponent comp;

  // Prevent global @ComponentScan and scan only dedicated packages. It isn't
  // clear how to avoid this, because otherwise bean2 will be used from
  // TestConfig (or even any other configuration from tests).
  @Configuration
  @Import(ApplicationConfig.class)
  @ComponentScan("beans.orig.bean")
  public static class Config {

  }

  @Test
  public void test() {
    assertNotNull(comp);
    assertEquals("bean1", comp.bean2.bean1.value);
    assertEquals("bean2", comp.bean2.value);
  }
}

// Use main test configuration. It is required to allow bean definition
// overriding. It isn't clear how to avoid this.
@SpringBootTest(properties = {"spring.main.allow-bean-definition-overriding=true"})
@RunWith(SpringRunner.class)
public class Test2 {

  @Autowired
  MyComponent comp;

  @Test
  public void test() {
    assertNotNull(comp);
    assertEquals("bean1", comp.bean2.bean1.value);
    assertEquals("bean2 from TestConfig", comp.bean2.value);
  }

}

// Use main test configuration. It is required to allow bean definition
// overriding. It isn't clear how to avoid this.
@SpringBootTest(properties = {"spring.main.allow-bean-definition-overriding=true"})
@RunWith(SpringRunner.class)
public class Test3 {

  @Autowired
  MyComponent comp;

  @Configuration
  @Import(TestConfig.class)
  public static class Config {
    @Bean
    public MyBean bean2() {
      return new MyBean("bean2 from Test");
    }
  }

  @Test
  public void test() {
    assertNotNull(comp);
    assertEquals("bean1", comp.bean2.bean1.value);
    assertEquals("bean2 from Test", comp.bean2.value);
  }
}

(See full sources on github)

Have there a drawbacks or improvements?

Update 2

Test2 is green when run from Eclipse but fails if run by gradle:

org.junit.ComparisonFailure: expected:<bean2[ from TestConfig]> but was:<bean2[]>

So, there are a big drawbacks...

Answer 1

One way to replace a bean with another in your tests would be to associate the different beans with different profiles via @Profile, then you can mention the active profile in the test with @ActiveProfiles. This will allow the test to only consider the beans that are activated for your specific profile.

@SpringBootApplication
public class Application {

  public static void main(String[] args) {
    SpringApplication.run(Application.class, args);
  }

  @Bean
  public Service1 service1() {
    return new Service1();
  }

  @Profile("dev")
  @Bean
  public Service2 service2Dev() {
    return new Service2(); // First implementation
  }

  @Profile("cloud")
  @Bean
  public Service2 service2Prod() {
    return new Service2(); // Second implementation
  }
}

If you want to simply use a mock instead of the regular bean for your test, then you can check out @MockBean from the spring testing documentation.