Spring Boot: @TestConfiguration Not Overriding Bean During Integration Test

Question

I have a Bean defined in a class decorated with @Configuration:

@Configuration
public class MyBeanConfig {
    @Bean
    public String configPath() {
        return "../production/environment/path";
    }
}

I have a class decorated with @TestConfiguration that should override this Bean:

@TestConfiguration
public class MyTestConfiguration {
    @Bean
    @Primary
    public String configPath() {
        return "/test/environment/path";
    }
}

The configPath bean is used to set the path to an external file containing a registration code that must be read during startup. It is used in an @Component class:

@Component
public class MyParsingComponent {
    private String CONFIG_PATH;
    
    @Autowired
    public void setCONFIG_PATH(String configPath) {
        this.CONFIG_PATH = configPath;
    }
}

While trying to debug this I set a breakpoint inside each method as well as the constructor of the test config class. The @TestConfiguration's constructor breakpoint is hit, so i know that my test configuration class instantiates, however the configPath method of that class is never hit. Instead, the configPath method of the normal @Configuration class is hit and the @Autowired String in MyParsingComponent is always ../production/environment/path rather than the expected /test/environment/path.

Not sure why this is happening. Any thoughts would be greatly appreciated.

Answer 1

As documented in the Detecting Test Configuration section of the Spring Boot reference manual, any beans configured in a top-level class annotated with @TestConfiguration will not be picked up via component scanning. So you have to explicitly register your @TestConfiguration class.

You can do that either via @Import(MyTestConfiguration.class) or @ContextConfiguration(classes = MyTestConfiguration.class) on your test class.

On the other hand, if your class annotated with @TestConfiguration were a static nested class within your test class, it would be registered automatically.

Answer 2

Make sure that the method name of your @Bean factory method does not match any existing bean name. I had issues with method names like config() or (in my case) prometheusConfig() which collided with existing bean names. Spring skips those factory methods silently and simply does not call them / does not instantiate the beans.

If you want to override a bean definition in your test, use the bean name explicitly as string parameter in your @Bean("beanName") annotation.

Answer 3

• Test configuration has to be explicitly imported in the test via @Import({MyTestConfiguration.class}).
• The name of the @Bean methods in @Configuration and @TestConfiguration have to be different. At least it makes difference in Spring Boot v2.2.
• Also make sure spring.main.allow-bean-definition-overriding=true otherwise the bean could not be overriden.

Answer 4

For me worked this code:

  @TestConfiguration // 1. necessary
  public class TestMessagesConfig {

    @Bean
    @Primary // 2. necessary
    public MessageSource testMessageSource() { // 3. different method name than in production code e.g. add test prefix

    }
  }

Answer 5

I struggled with a related problem, whereby even though I was using an inner static class, my test bean was not being registered.

It turns out, You still need to add your inner static class to the @ContextConfiguration class array, otherwise the beans inside the @TestConfiguration doesn't get picked up.

public interface Foo {
    String execute();
}

public class FooService {
    private final Foo foo;

    FooService(Foo foo) {
        this.foo = foo;
    }

    public String execute() {
        return foo.execute();
    }
}

@ExtendWith(SpringExtension.class)
@ContextConfiguration(classes = {FooService.class, FooTest.FooTestConfig.class})
public class FooTest {
    @Autowired
    FooService fooService;

    @Test
    void test() {
        Assertions.assertEquals("MY_TEST_BEAN", fooService.execute());
    }

    @TestConfiguration
    static class FooTestConfig {
        @Bean
        public Foo getFooBean() {
            return () -> "MY_TEST_BEAN";
        }
    }
}

Answer 6

I came across a similar issue recently and got it sorted out by annotating my testing bean with @Primary as well as @Bean. Not sure why it's required, which seems not documented in the Spring doc. The version of my SpringBoot is 2.0.3.

Answer 7

In my case replacing @Import(TestConfig.class) with @ContextConfiguration(classes=TestConfig.class) did the trick. For some reason, some of the beans from TestConfig but 1 wasn't until I replaced @Import with @ContextConfiguration. This was also mentioned in some comments that were hidden because they had no upvotes.

Answer 8

I found it odd how several answers stated that the names of the @Beans have to be different from each other. How would that make one override the other?
There wasn't one specific answer that worked for me, but I've solved the issue by combining some of their advices.

Here's what worked for me.

Main configuration class:

@Configuration
public class SpringConfiguration {

    @Bean
    BeanInterface myBean() {
        return new BeanImplementation();
    }
    
    @Bean
    OtherClass otherBean() {
        return new OtherClass();
    }
}

Test configuration class:

@TestConfiguration
public class TestSpringConfiguration {

    @Bean
    @Primary
    BeanInterface myBean() {
        return new TestBeanImplementation();
    }
}

Test class:

@SpringBootTest(classes = TestSpringConfiguration.class, 
        properties = "spring.main.allow-bean-definition-overriding=true")
public class Tests {
    
    @Test
    public void test() {
        // do stuff
    }
}

In this way, the "myBean" bean instance is the one defined in the TestSpringConfiguration class, while "otherBean" is the one defined in the SpringConfiguration class, since it's not overridden.
If I gave two different names to the "myBean" beans, the "real" one would still be initialized and, in my case, would give an error during tests, since it needs something that's only available at runtime in its proper environment.
Once I gave both the same name, Spring would throw an error saying that they were conflicting. Hence why I had to specify the property spring.main.allow-bean-definition-overriding=true in the @SpringBootTest annotation of the test class.

By the way, if you're NOT using Spring Boot, I guess these alternative annotations could work for you:

@ExtendWith(value = SpringExtension.class)
@ContextConfiguration(loader = AnnotationConfigContextLoader.class, // <- not sure about this one
        classes = { SpringConfiguration.class, TestSpringConfiguration.class })
public class Tests {
    
    @Test
    public void test() {
        // do stuff
    }
}

Then, you would still have to set the property spring.main.allow-bean-definition-overriding=true in the test application.yml or application.properties file, or in some other way via code on startup.

Note: I'm not 100% sure that you would need the loader = AnnotationConfigContextLoader.class thing. Try without it, first. I needed it in a project of mine which had Spring without Boot, but I can't remember whether it's a standard thing to set or I needed it for some specific reason.

Answer 9

In my case it was an issue with @RunWith(SpringRunner.class), I'm not exactly sure why it wasn't working, I was following this - Testing in Spring Boot

But after replacing that with @ExtendWith(SpringExtension.class) the inner static @TestConfiguration class created the beans as expected.

Maybe a version mismatch - I'm using Spring Boot 2.7.2.