Java Spring Boot Test: How to exclude java configuration class from test context

Typically you would use Spring profiles to either include or exclude Spring beans, depending on which profile is active. In your situation you could define a production profile, which could be enabled by default; and a test profile. In your production config class you would specify the production profile:

@Configuration
@PropertySource("classpath:otp.properties")
@Profile({ "production" })
public class OTPConfig {
}

The test config class would specify the test profile:

@TestConfiguration
@Import({ TestDataSourceConfig.class, TestMailConfiguration.class,    TestOTPConfig.class })
@TestPropertySource("classpath:amc-test.properties")
@Profile({ "test" })
public class TestAMCApplicationConfig extends AMCApplicationConfig {
}

Then, in your test class you should be able to say which profiles are active:

@RunWith(SpringRunner.class)
@SpringBootTest(classes = TestAMCApplicationConfig.class)
@ActiveProfiles({ "test" })
public class AuthUserServiceTest {
  ....
}

When you run your project in production you would include "production" as a default active profile, by setting an environment variable:

JAVA_OPTS="-Dspring.profiles.active=production"

Of course your production startup script might use something else besides JAVA_OPTS to set the Java environment variables, but somehow you should set spring.profiles.active.

You can also just mock the configuration you don't need. For example:

@MockBean
private AnyConfiguration conf;

Put it into your test class. This should help to avoid that the real AnyConfiguration is being loaded.

You can also use @ConditionalOnProperty like below:

@ConditionalOnProperty(value="otpConfig", havingValue="production")
@Configuration
@PropertySource("classpath:otp.properties")
public class OTPConfig { }

and for tests:

@ConditionalOnProperty(value="otpConfig", havingValue="test")
@Configuration
@PropertySource("classpath:otp-test.properties")
public class TestOTPConfig { }

Then specify in your main/resources/config/application.yml

otpConfig: production

and in your test/resources/config/application.yml

otpConfig: test

Create the same class as an "useless" mirror in test folder, for example:

In src you have /app/MyConfig.java

Create /app/MyConfig.java in test folder with @Configuration and leave empty body inside it.

Additionally, for excluding auto configuration:

@EnableAutoConfiguration(exclude=CassandraDataAutoConfiguration.class)
public class // ...

Set a profile during tests and load OTPConfig only if the profile is not active.

@Profile("!test")
@Configuration
class OTPConfig { ... }

@SpringBootTest(properties = ["spring.profiles.include=test"])
public class AuthUserServiceTest { .... }

SpringBoot 3. It works for me, now we exclude two configs from the context (SomeConfig.class, AlsoOneConfig.class)

@MockBean(classes = {SomeConfig.class, AlsoOneConfig.class})   
@TestConfiguration
public class YourTestConfig {
  .....
  //put here some beans if you need
}

and now we can use this test config, like that

@SpringBootTest(classes = {YourTestConfig.class})
class ComponentTest {
 // put here your tests
}

Adding an extra non-touching-production-code option.

Create a TypeExcludeFilter,

public class ExcludeConfigs extends TypeExcludeFilter
{
    @Override
    public boolean match(final MetadataReader metadataReader, final MetadataReaderFactory metadataReaderFactory) throws IOException
    {
       if (metadataReader.getClassMetadata().getClassName().equals(OTPConfig.class.getName()))
       {
            return true;
        }
        return false;
    }

    (*1)
}

And on the SpringBootTest class add the annotation

@TypeExcludeFilters(value = {ExcludeConfigs.class})

NOTES

*1: According to javadoc you should add hashCode and equals implementations, I tried with lombok ones and worked.

You can also add this class an inner at the SpringBootTest with correct reference and also works.

Source: answer from https://github.com/spring-projects/spring-boot/issues/15068#issuecomment-435774681.

The easiest way that I use -

1. Put @ConditionalOnProperty in my main source code.
2. Then define a test bean and add it as a part of the test configuration. Either import that configuration in the main test class or any other way. This is only needed when you need to register a test bean. If you do not need that bean then go to next step.
3. Add a property in application.properties under src/test/resources to disable the use of configuration class that is present in the main folder.

Voila!