{"id":94660,"date":"2019-08-07T07:00:50","date_gmt":"2019-08-07T04:00:50","guid":{"rendered":"https:\/\/www.javacodegeeks.com\/?p=94660"},"modified":"2019-08-08T09:06:26","modified_gmt":"2019-08-08T06:06:26","slug":"testing-spring-boot-conditionals-sane-way","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2019\/08\/testing-spring-boot-conditionals-sane-way.html","title":{"rendered":"Testing Spring Boot conditionals the sane way"},"content":{"rendered":"

If you are more or less experienced Spring Boot<\/a> user, it is very luckily that at some point you may need to run into the situation when the particular beans or configurations have to be injected conditionally<\/a>. The mechanics of it is well understood<\/a> but sometimes the testing such conditions (and their combinations) could get messy. In this post we are going to talk about some possible (arguably, sane) ways to approach that.<\/p>\n

Since Spring Boot 1.5.x<\/a> is still widely used (nonetheless it is racing towards the EOL this August<\/a>), we would include it along with Spring Boot 2.1.x<\/a>, both with JUnit 4.x<\/a> and JUnit 5.x<\/a>. The techniques we are about to cover are equally applicable to the regular configuration classes as well as auto-configurations<\/a> classes.<\/p>\n

The example we will be playing with would be related to our home-made logging. Let us assume our Spring Boot<\/a> application requires some bean for dedicated logger with name “sample”<\/b>. In certain circumstances however this logger has to be disabled (or become effectively a noop), so the property logging.enabled<\/b> serves like a kill switch here. We use Slf4j<\/a> and Logback<\/a> in this example, but it is not really important. The LoggingConfiguration<\/b> snippet below reflects this idea.<\/p>\n

\n
\n\n\n\n
\n
01<\/div>\n
02<\/div>\n
03<\/div>\n
04<\/div>\n
05<\/div>\n
06<\/div>\n
07<\/div>\n
08<\/div>\n
09<\/div>\n
10<\/div>\n
11<\/div>\n
12<\/div>\n
13<\/div>\n
14<\/div>\n
15<\/div>\n
16<\/div>\n
17<\/div>\n<\/td>\n
\n
\n
@Configuration<\/code><\/div>\n
public<\/code> class<\/code> LoggingConfiguration {<\/code><\/div>\n
    <\/code>@Configuration<\/code><\/div>\n
    <\/code>@ConditionalOnProperty<\/code>(name = <\/code>\"logging.enabled\"<\/code>, matchIfMissing = <\/code>true<\/code>)<\/code><\/div>\n
    <\/code>public<\/code> static<\/code> class<\/code> Slf4jConfiguration {<\/code><\/div>\n
        <\/code>@Bean<\/code><\/div>\n
        <\/code>Logger logger() {<\/code><\/div>\n
            <\/code>return<\/code> LoggerFactory.getLogger(<\/code>\"sample\"<\/code>);<\/code><\/div>\n
        <\/code>}<\/code><\/div>\n
    <\/code>}<\/code><\/div>\n
    <\/code> <\/div>\n
    <\/code>@Bean<\/code><\/div>\n
    <\/code>@ConditionalOnMissingBean<\/code><\/div>\n
    <\/code>Logger logger() {<\/code><\/div>\n
        <\/code>return<\/code> new<\/code> NOPLoggerFactory().getLogger(<\/code>\"sample\"<\/code>); <\/code><\/div>\n
    <\/code>}<\/code><\/div>\n
}<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n

So how would we test that? Spring Boot<\/a> (and Spring Framework<\/a> in general) has always offered the outstanding test scaffolding support<\/a>. The @SpringBootTest<\/b> and @TestPropertySource<\/b> annotations allow to quickly bootstrap the application context with the customized properties. There is one issue though: they are applied per test class level, not a per test method. It certainly makes sense but basically requires you to create a test class per combination of conditionals.<\/p>\n

If you are still with JUnit 4.x<\/a>, there is one trick you may found useful which exploits Enclosed<\/b> runner, the hidden gem of the framework.<\/p>\n

\n
\n\n\n\n
\n
01<\/div>\n
02<\/div>\n
03<\/div>\n
04<\/div>\n
05<\/div>\n
06<\/div>\n
07<\/div>\n
08<\/div>\n
09<\/div>\n
10<\/div>\n
11<\/div>\n
12<\/div>\n
13<\/div>\n
14<\/div>\n
15<\/div>\n
16<\/div>\n
17<\/div>\n
18<\/div>\n
19<\/div>\n
20<\/div>\n
21<\/div>\n
22<\/div>\n
23<\/div>\n
24<\/div>\n
25<\/div>\n<\/td>\n
\n
\n
@RunWith<\/code>(Enclosed.<\/code>class<\/code>)<\/code><\/div>\n
public<\/code> class<\/code> LoggingConfigurationTest {<\/code><\/div>\n
    <\/code>@RunWith<\/code>(SpringRunner.<\/code>class<\/code>)<\/code><\/div>\n
    <\/code>@SpringBootTest<\/code><\/div>\n
    <\/code>public<\/code> static<\/code> class<\/code> LoggerEnabledTest {<\/code><\/div>\n
        <\/code>@Autowired<\/code> private<\/code> Logger logger;<\/code><\/div>\n
        <\/code> <\/div>\n
        <\/code>@Test<\/code><\/div>\n
        <\/code>public<\/code> void<\/code> loggerShouldBeSlf4j() {<\/code><\/div>\n
            <\/code>assertThat(logger).isInstanceOf(ch.qos.logback.classic.Logger.<\/code>class<\/code>);<\/code><\/div>\n
        <\/code>}<\/code><\/div>\n
    <\/code>}<\/code><\/div>\n
    <\/code> <\/div>\n
    <\/code>@RunWith<\/code>(SpringRunner.<\/code>class<\/code>)<\/code><\/div>\n
    <\/code>@SpringBootTest<\/code><\/div>\n
    <\/code>@TestPropertySource<\/code>(properties = <\/code>\"logging.enabled=false\"<\/code>)<\/code><\/div>\n
    <\/code>public<\/code> static<\/code> class<\/code> LoggerDisabledTest {<\/code><\/div>\n
        <\/code>@Autowired<\/code> private<\/code> Logger logger;<\/code><\/div>\n
        <\/code> <\/div>\n
        <\/code>@Test<\/code><\/div>\n
        <\/code>public<\/code> void<\/code> loggerShouldBeNoop() {<\/code><\/div>\n
            <\/code>assertThat(logger).isSameAs(NOPLogger.NOP_LOGGER);<\/code><\/div>\n
        <\/code>}<\/code><\/div>\n
    <\/code>}<\/code><\/div>\n
}<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n

You still have the class per condition but at least they are all in the same nest. With JUnit 5.x<\/a>, some things got easier but not to the level as one might expect. Unfortunately, Spring Boot 1.5.x<\/a> does not support JUnit 5.x<\/a> natively, so we have to rely on extension provided by spring-test-junit5<\/a> community module. Here are the relevant changes in pom.xml<\/b>, please notice that junit<\/b> is explicitly excluded from the spring-boot-starter-test<\/b> dependencies graph.<\/p>\n

\n
\n\n\n\n
\n
01<\/div>\n
02<\/div>\n
03<\/div>\n
04<\/div>\n
05<\/div>\n
06<\/div>\n
07<\/div>\n
08<\/div>\n
09<\/div>\n
10<\/div>\n
11<\/div>\n
12<\/div>\n
13<\/div>\n
14<\/div>\n
15<\/div>\n
16<\/div>\n
17<\/div>\n
18<\/div>\n
19<\/div>\n
20<\/div>\n
21<\/div>\n
22<\/div>\n
23<\/div>\n
24<\/div>\n
25<\/div>\n
26<\/div>\n
27<\/div>\n
28<\/div>\n
29<\/div>\n
30<\/div>\n
31<\/div>\n
32<\/div>\n<\/td>\n
\n
\n
<<\/code>dependency<\/code>><\/code><\/div>\n
    <\/code><<\/code>groupId<\/code>>org.springframework.boot<\/<\/code>groupId<\/code>><\/code><\/div>\n
    <\/code><<\/code>artifactId<\/code>>spring-boot-starter-test<\/<\/code>artifactId<\/code>><\/code><\/div>\n
    <\/code><<\/code>scope<\/code>>test<\/<\/code>scope<\/code>><\/code><\/div>\n
    <\/code><<\/code>exclusions<\/code>><\/code><\/div>\n
        <\/code><<\/code>exclusion<\/code>><\/code><\/div>\n
            <\/code><<\/code>groupId<\/code>>junit<\/<\/code>groupId<\/code>><\/code><\/div>\n
            <\/code><<\/code>artifactId<\/code>>junit<\/<\/code>artifactId<\/code>><\/code><\/div>\n
        <\/code><\/<\/code>exclusion<\/code>><\/code><\/div>\n
    <\/code><\/<\/code>exclusions<\/code>><\/code><\/div>\n
<\/<\/code>dependency<\/code>><\/code><\/div>\n
 <\/div>\n
<<\/code>dependency<\/code>><\/code><\/div>\n
    <\/code><<\/code>groupId<\/code>>com.github.sbrannen<\/<\/code>groupId<\/code>><\/code><\/div>\n
    <\/code><<\/code>artifactId<\/code>>spring-test-junit5<\/<\/code>artifactId<\/code>><\/code><\/div>\n
    <\/code><<\/code>version<\/code>>1.5.0<\/<\/code>version<\/code>><\/code><\/div>\n
    <\/code><<\/code>scope<\/code>>test<\/<\/code>scope<\/code>><\/code><\/div>\n
<\/<\/code>dependency<\/code>><\/code><\/div>\n
 <\/div>\n
<<\/code>dependency<\/code>><\/code><\/div>\n
    <\/code><<\/code>groupId<\/code>>org.junit.jupiter<\/<\/code>groupId<\/code>><\/code><\/div>\n
    <\/code><<\/code>artifactId<\/code>>junit-jupiter-api<\/<\/code>artifactId<\/code>><\/code><\/div>\n
    <\/code><<\/code>version<\/code>>5.5.0<\/<\/code>version<\/code>><\/code><\/div>\n
    <\/code><<\/code>scope<\/code>>test<\/<\/code>scope<\/code>><\/code><\/div>\n
<\/<\/code>dependency<\/code>><\/code><\/div>\n
 <\/div>\n
<<\/code>dependency<\/code>><\/code><\/div>\n
    <\/code><<\/code>groupId<\/code>>org.junit.jupiter<\/<\/code>groupId<\/code>><\/code><\/div>\n
    <\/code><<\/code>artifactId<\/code>>junit-jupiter-engine<\/<\/code>artifactId<\/code>><\/code><\/div>\n
    <\/code><<\/code>version<\/code>>5.5.0<\/<\/code>version<\/code>><\/code><\/div>\n
    <\/code><<\/code>scope<\/code>>test<\/<\/code>scope<\/code>><\/code><\/div>\n
<\/<\/code>dependency<\/code>><\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n

The test case itself is not very different besides usage of the @Nested<\/b> annotation, which comes from JUnit 5.x<\/a> to support tests as inner classes.

<\/div> <\/div><\/p>\n
\n
\n\n\n\n
\n
01<\/div>\n
02<\/div>\n
03<\/div>\n
04<\/div>\n
05<\/div>\n
06<\/div>\n
07<\/div>\n
08<\/div>\n
09<\/div>\n
10<\/div>\n
11<\/div>\n
12<\/div>\n
13<\/div>\n
14<\/div>\n
15<\/div>\n
16<\/div>\n
17<\/div>\n
18<\/div>\n
19<\/div>\n
20<\/div>\n
21<\/div>\n
22<\/div>\n
23<\/div>\n
24<\/div>\n
25<\/div>\n
26<\/div>\n
27<\/div>\n
28<\/div>\n<\/td>\n
\n
\n
public<\/code> class<\/code> LoggingConfigurationTest {<\/code><\/div>\n
    <\/code>@Nested<\/code><\/div>\n
    <\/code>@ExtendWith<\/code>(SpringExtension.<\/code>class<\/code>)<\/code><\/div>\n
    <\/code>@SpringBootTest<\/code><\/div>\n
    <\/code>@DisplayName<\/code>(<\/code>\"Logging is enabled, expecting Slf4j logger\"<\/code>)<\/code><\/div>\n
    <\/code>public<\/code> static<\/code> class<\/code> LoggerEnabledTest {<\/code><\/div>\n
        <\/code>@Autowired<\/code> private<\/code> Logger logger;<\/code><\/div>\n
        <\/code> <\/div>\n
        <\/code>@Test<\/code><\/div>\n
        <\/code>public<\/code> void<\/code> loggerShouldBeSlf4j() {<\/code><\/div>\n
            <\/code>assertThat(logger).isInstanceOf(ch.qos.logback.classic.Logger.<\/code>class<\/code>);<\/code><\/div>\n
        <\/code>}<\/code><\/div>\n
    <\/code>}<\/code><\/div>\n
    <\/code> <\/div>\n
    <\/code>@Nested<\/code><\/div>\n
    <\/code>@ExtendWith<\/code>(SpringExtension.<\/code>class<\/code>)<\/code><\/div>\n
    <\/code>@SpringBootTest<\/code><\/div>\n
    <\/code>@TestPropertySource<\/code>(properties = <\/code>\"logging.enabled=false\"<\/code>)<\/code><\/div>\n
    <\/code>@DisplayName<\/code>(<\/code>\"Logging is disabled, expecting NOOP logger\"<\/code>)<\/code><\/div>\n
    <\/code>public<\/code> static<\/code> class<\/code> LoggerDisabledTest {<\/code><\/div>\n
        <\/code>@Autowired<\/code> private<\/code> Logger logger;<\/code><\/div>\n
        <\/code> <\/div>\n
        <\/code>@Test<\/code><\/div>\n
        <\/code>public<\/code> void<\/code> loggerShouldBeNoop() {<\/code><\/div>\n
            <\/code>assertThat(logger).isSameAs(NOPLogger.NOP_LOGGER);<\/code><\/div>\n
        <\/code>}<\/code><\/div>\n
    <\/code>}<\/code><\/div>\n
}<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n

If you try to run the tests from the command line using Apache Maven<\/a> and Maven Surefire plugin<\/a>, you might be surprised to see that none of them were executed during the build. The issue is that … all nested classes are excluded<\/a> … so we need to put in place another workaround<\/a>.<\/p>\n

\n
\n\n\n\n
\n
01<\/div>\n
02<\/div>\n
03<\/div>\n
04<\/div>\n
05<\/div>\n
06<\/div>\n
07<\/div>\n
08<\/div>\n
09<\/div>\n
10<\/div>\n<\/td>\n
\n
\n
<<\/code>plugin<\/code>><\/code><\/div>\n
    <\/code><<\/code>groupId<\/code>>org.apache.maven.plugins<\/<\/code>groupId<\/code>><\/code><\/div>\n
    <\/code><<\/code>artifactId<\/code>>maven-surefire-plugin<\/<\/code>artifactId<\/code>><\/code><\/div>\n
    <\/code><<\/code>version<\/code>>2.22.2<\/<\/code>version<\/code>><\/code><\/div>\n
    <\/code><<\/code>configuration<\/code>><\/code><\/div>\n
        <\/code><<\/code>excludes<\/code>><\/code><\/div>\n
            <\/code><<\/code>exclude<\/code> \/><\/code><\/div>\n
        <\/code><\/<\/code>excludes<\/code>><\/code><\/div>\n
    <\/code><\/<\/code>configuration<\/code>><\/code><\/div>\n
<\/<\/code>plugin<\/code>><\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n

With that, things should be rolling smoothly. But enough about legacy<\/a>, the Spring Boot 2.1.x<\/a> comes as the complete game changer. The family of the context runners, ApplicationContextRunner<\/b>, ReactiveWebApplicationContextRunner<\/b> and WebApplicationContextRunner<\/b>, provide an easy and straightforward way to tailor the context on per test method level, keeping the test executions incredibly fast.<\/p>\n

\n
\n\n\n\n
\n
01<\/div>\n
02<\/div>\n
03<\/div>\n
04<\/div>\n
05<\/div>\n
06<\/div>\n
07<\/div>\n
08<\/div>\n
09<\/div>\n
10<\/div>\n
11<\/div>\n
12<\/div>\n
13<\/div>\n
14<\/div>\n
15<\/div>\n
16<\/div>\n
17<\/div>\n
18<\/div>\n
19<\/div>\n
20<\/div>\n
21<\/div>\n<\/td>\n
\n
\n
public<\/code> class<\/code> LoggingConfigurationTest {<\/code><\/div>\n
    <\/code>private<\/code> final<\/code> ApplicationContextRunner runner = <\/code>new<\/code> ApplicationContextRunner()<\/code><\/div>\n
        <\/code>.withConfiguration(UserConfigurations.of(LoggingConfiguration.<\/code>class<\/code>));<\/code><\/div>\n
    <\/code> <\/div>\n
    <\/code>@Test<\/code><\/div>\n
    <\/code>public<\/code> void<\/code> loggerShouldBeSlf4j() {<\/code><\/div>\n
        <\/code>runner<\/code><\/div>\n
            <\/code>.run(ctx -> <\/code><\/div>\n
                <\/code>assertThat(ctx.getBean(Logger.<\/code>class<\/code>)).isInstanceOf(Logger.<\/code>class<\/code>)<\/code><\/div>\n
            <\/code>);<\/code><\/div>\n
    <\/code>}<\/code><\/div>\n
    <\/code> <\/div>\n
    <\/code>@Test<\/code><\/div>\n
    <\/code>public<\/code> void<\/code> loggerShouldBeNoop() {<\/code><\/div>\n
        <\/code>runner<\/code><\/div>\n
            <\/code>.withPropertyValues(<\/code>\"logging.enabled=false\"<\/code>)<\/code><\/div>\n
            <\/code>.run(ctx -> <\/code><\/div>\n
                <\/code>assertThat(ctx.getBean(Logger.<\/code>class<\/code>)).isSameAs(NOPLogger.NOP_LOGGER)<\/code><\/div>\n
            <\/code>);<\/code><\/div>\n
    <\/code>}<\/code><\/div>\n
}<\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n

It looks really great. The JUnit 5.x<\/a> support in Spring Boot 2.1.x<\/a> is much better and with the the upcoming 2.2<\/b><\/b> release, JUnit 5.x<\/a> will be the default engine<\/a> (not to worry, the old JUnit 4.x<\/a> will still be supported). As of now, the switch to JUnit 5.x<\/a> needs a bit of work on dependencies side.<\/p>\n

\n
\n\n\n\n
\n
01<\/div>\n
02<\/div>\n
03<\/div>\n
04<\/div>\n
05<\/div>\n
06<\/div>\n
07<\/div>\n
08<\/div>\n
09<\/div>\n
10<\/div>\n
11<\/div>\n
12<\/div>\n
13<\/div>\n
14<\/div>\n
15<\/div>\n
16<\/div>\n
17<\/div>\n
18<\/div>\n
19<\/div>\n
20<\/div>\n
21<\/div>\n
22<\/div>\n
23<\/div>\n<\/td>\n
\n
\n
<<\/code>dependency<\/code>><\/code><\/div>\n
    <\/code><<\/code>groupId<\/code>>org.springframework.boot<\/<\/code>groupId<\/code>><\/code><\/div>\n
    <\/code><<\/code>artifactId<\/code>>spring-boot-starter-test<\/<\/code>artifactId<\/code>><\/code><\/div>\n
    <\/code><<\/code>scope<\/code>>test<\/<\/code>scope<\/code>><\/code><\/div>\n
    <\/code><<\/code>exclusions<\/code>><\/code><\/div>\n
        <\/code><<\/code>exclusion<\/code>><\/code><\/div>\n
            <\/code><<\/code>groupId<\/code>>junit<\/<\/code>groupId<\/code>><\/code><\/div>\n
            <\/code><<\/code>artifactId<\/code>>junit<\/<\/code>artifactId<\/code>><\/code><\/div>\n
        <\/code><\/<\/code>exclusion<\/code>><\/code><\/div>\n
    <\/code><\/<\/code>exclusions<\/code>><\/code><\/div>\n
<\/<\/code>dependency<\/code>><\/code><\/div>\n
 <\/div>\n
<<\/code>dependency<\/code>><\/code><\/div>\n
    <\/code><<\/code>groupId<\/code>>org.junit.jupiter<\/<\/code>groupId<\/code>><\/code><\/div>\n
    <\/code><<\/code>artifactId<\/code>>junit-jupiter-api<\/<\/code>artifactId<\/code>><\/code><\/div>\n
    <\/code><<\/code>scope<\/code>>test<\/<\/code>scope<\/code>><\/code><\/div>\n
<\/<\/code>dependency<\/code>><\/code><\/div>\n
 <\/div>\n
<<\/code>dependency<\/code>><\/code><\/div>\n
    <\/code><<\/code>groupId<\/code>>org.junit.jupiter<\/<\/code>groupId<\/code>><\/code><\/div>\n
    <\/code><<\/code>artifactId<\/code>>junit-jupiter-engine<\/<\/code>artifactId<\/code>><\/code><\/div>\n
    <\/code><<\/code>scope<\/code>>test<\/<\/code>scope<\/code>><\/code><\/div>\n
<\/<\/code>dependency<\/code>><\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n

As an additional step, you may need to use recent Maven Surefire plugin<\/a>, 2.22.0<\/b> or above, with out-of-the box JUnit 5.x<\/a> support. The the snippet below illustrates that.<\/p>\n

\n
\n\n\n\n
\n
1<\/div>\n
2<\/div>\n
3<\/div>\n
4<\/div>\n
5<\/div>\n<\/td>\n
\n
\n
<<\/code>plugin<\/code>><\/code><\/div>\n
    <\/code><<\/code>groupId<\/code>>org.apache.maven.plugins<\/<\/code>groupId<\/code>><\/code><\/div>\n
    <\/code><<\/code>artifactId<\/code>>maven-surefire-plugin<\/<\/code>artifactId<\/code>><\/code><\/div>\n
    <\/code><<\/code>version<\/code>>2.22.2<\/<\/code>version<\/code>><\/code><\/div>\n
<\/<\/code>plugin<\/code>><\/code><\/div>\n<\/div>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n

The sample configuration we have worked with is pretty naive, many of the real-world applications would end up with quite complex contexts built out of many conditionals. The flexibility and enormous opportunities that come out of the context runners, the invaluable addition to the Spring Boot 2.x<\/a> test scaffolding, are just the live savers, please keep them in mind.<\/p>\n

The complete project sources are available on Github<\/a>.<\/p>\n

\n\n\n\n
\n

Published on Java Code Geeks with permission by Andrey Redko, partner at our JCG program<\/a>. See the original article here: Testing Spring Boot conditionals the sane way<\/a><\/p>\n

Opinions expressed by Java Code Geeks contributors are their own.<\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n","protected":false},"excerpt":{"rendered":"

If you are more or less experienced Spring Boot user, it is very luckily that at some point you may need to run into the situation when the particular beans or configurations have to be injected conditionally. The mechanics of it is well understood but sometimes the testing such conditions (and their combinations) could get …<\/p>\n","protected":false},"author":141,"featured_media":240,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[8],"tags":[274,670,854,273],"class_list":["post-94660","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-enterprise-java","tag-junit","tag-maven","tag-spring-boot","tag-testing"],"yoast_head":"\nTesting Spring Boot conditionals the sane way - Java Code Geeks<\/title>\n<meta name=\"description\" content=\"Interested to learn about Spring Boot conditionals? Check our article explaining how to test spring boot whenbeans have to be injected conditionally\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.javacodegeeks.com\/2019\/08\/testing-spring-boot-conditionals-sane-way.html\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Testing Spring Boot conditionals the sane way - Java Code Geeks\" \/>\n<meta property=\"og:description\" content=\"Interested to learn about Spring Boot conditionals? Check our article explaining how to test spring boot whenbeans have to be injected conditionally\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.javacodegeeks.com\/2019\/08\/testing-spring-boot-conditionals-sane-way.html\" \/>\n<meta property=\"og:site_name\" content=\"Java Code Geeks\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/javacodegeeks\" \/>\n<meta property=\"article:published_time\" content=\"2019-08-07T04:00:50+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2019-08-08T06:06:26+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2012\/10\/spring-logo.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"150\" \/>\n\t<meta property=\"og:image:height\" content=\"150\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"Andrey Redko\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@javacodegeeks\" \/>\n<meta name=\"twitter:site\" content=\"@javacodegeeks\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Andrey Redko\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"10 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2019\\\/08\\\/testing-spring-boot-conditionals-sane-way.html#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2019\\\/08\\\/testing-spring-boot-conditionals-sane-way.html\"},\"author\":{\"name\":\"Andrey Redko\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#\\\/schema\\\/person\\\/771a6504862edc45322776832cbce413\"},\"headline\":\"Testing Spring Boot conditionals the sane way\",\"datePublished\":\"2019-08-07T04:00:50+00:00\",\"dateModified\":\"2019-08-08T06:06:26+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2019\\\/08\\\/testing-spring-boot-conditionals-sane-way.html\"},\"wordCount\":710,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2019\\\/08\\\/testing-spring-boot-conditionals-sane-way.html#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.javacodegeeks.com\\\/wp-content\\\/uploads\\\/2012\\\/10\\\/spring-logo.jpg\",\"keywords\":[\"JUnit\",\"Maven\",\"Spring Boot\",\"Testing\"],\"articleSection\":[\"Enterprise Java\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/www.javacodegeeks.com\\\/2019\\\/08\\\/testing-spring-boot-conditionals-sane-way.html#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2019\\\/08\\\/testing-spring-boot-conditionals-sane-way.html\",\"url\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2019\\\/08\\\/testing-spring-boot-conditionals-sane-way.html\",\"name\":\"Testing Spring Boot conditionals the sane way - Java Code Geeks\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2019\\\/08\\\/testing-spring-boot-conditionals-sane-way.html#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2019\\\/08\\\/testing-spring-boot-conditionals-sane-way.html#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.javacodegeeks.com\\\/wp-content\\\/uploads\\\/2012\\\/10\\\/spring-logo.jpg\",\"datePublished\":\"2019-08-07T04:00:50+00:00\",\"dateModified\":\"2019-08-08T06:06:26+00:00\",\"description\":\"Interested to learn about Spring Boot conditionals? Check our article explaining how to test spring boot whenbeans have to be injected conditionally\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2019\\\/08\\\/testing-spring-boot-conditionals-sane-way.html#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.javacodegeeks.com\\\/2019\\\/08\\\/testing-spring-boot-conditionals-sane-way.html\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2019\\\/08\\\/testing-spring-boot-conditionals-sane-way.html#primaryimage\",\"url\":\"https:\\\/\\\/www.javacodegeeks.com\\\/wp-content\\\/uploads\\\/2012\\\/10\\\/spring-logo.jpg\",\"contentUrl\":\"https:\\\/\\\/www.javacodegeeks.com\\\/wp-content\\\/uploads\\\/2012\\\/10\\\/spring-logo.jpg\",\"width\":150,\"height\":150,\"caption\":\"spring-interview-questions-answers\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/2019\\\/08\\\/testing-spring-boot-conditionals-sane-way.html#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/www.javacodegeeks.com\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Java\",\"item\":\"https:\\\/\\\/www.javacodegeeks.com\\\/category\\\/java\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Enterprise Java\",\"item\":\"https:\\\/\\\/www.javacodegeeks.com\\\/category\\\/java\\\/enterprise-java\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Testing Spring Boot conditionals the sane way\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#website\",\"url\":\"https:\\\/\\\/www.javacodegeeks.com\\\/\",\"name\":\"Java Code Geeks\",\"description\":\"Java Developers Resource Center\",\"publisher\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#organization\"},\"alternateName\":\"JCG\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.javacodegeeks.com\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#organization\",\"name\":\"Exelixis Media P.C.\",\"url\":\"https:\\\/\\\/www.javacodegeeks.com\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/www.javacodegeeks.com\\\/wp-content\\\/uploads\\\/2022\\\/06\\\/exelixis-logo.png\",\"contentUrl\":\"https:\\\/\\\/www.javacodegeeks.com\\\/wp-content\\\/uploads\\\/2022\\\/06\\\/exelixis-logo.png\",\"width\":864,\"height\":246,\"caption\":\"Exelixis Media P.C.\"},\"image\":{\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#\\\/schema\\\/logo\\\/image\\\/\"},\"sameAs\":[\"https:\\\/\\\/www.facebook.com\\\/javacodegeeks\",\"https:\\\/\\\/x.com\\\/javacodegeeks\"]},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.javacodegeeks.com\\\/#\\\/schema\\\/person\\\/771a6504862edc45322776832cbce413\",\"name\":\"Andrey Redko\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/16419ce8394173028eddaeb992859862bab50cfcf74589fa9bb9a3dd8bb27518?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/16419ce8394173028eddaeb992859862bab50cfcf74589fa9bb9a3dd8bb27518?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/16419ce8394173028eddaeb992859862bab50cfcf74589fa9bb9a3dd8bb27518?s=96&d=mm&r=g\",\"caption\":\"Andrey Redko\"},\"description\":\"Andriy is a well-grounded software developer with more then 12 years of practical experience using Java\\\/EE, C#\\\/.NET, C++, Groovy, Ruby, functional programming (Scala), databases (MySQL, PostgreSQL, Oracle) and NoSQL solutions (MongoDB, Redis).\",\"sameAs\":[\"http:\\\/\\\/aredko.blogspot.com\\\/\",\"http:\\\/\\\/ca.linkedin.com\\\/in\\\/aredko\"],\"url\":\"https:\\\/\\\/www.javacodegeeks.com\\\/author\\\/andrey-redko\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Testing Spring Boot conditionals the sane way - Java Code Geeks","description":"Interested to learn about Spring Boot conditionals? Check our article explaining how to test spring boot whenbeans have to be injected conditionally","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.javacodegeeks.com\/2019\/08\/testing-spring-boot-conditionals-sane-way.html","og_locale":"en_US","og_type":"article","og_title":"Testing Spring Boot conditionals the sane way - Java Code Geeks","og_description":"Interested to learn about Spring Boot conditionals? Check our article explaining how to test spring boot whenbeans have to be injected conditionally","og_url":"https:\/\/www.javacodegeeks.com\/2019\/08\/testing-spring-boot-conditionals-sane-way.html","og_site_name":"Java Code Geeks","article_publisher":"https:\/\/www.facebook.com\/javacodegeeks","article_published_time":"2019-08-07T04:00:50+00:00","article_modified_time":"2019-08-08T06:06:26+00:00","og_image":[{"width":150,"height":150,"url":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2012\/10\/spring-logo.jpg","type":"image\/jpeg"}],"author":"Andrey Redko","twitter_card":"summary_large_image","twitter_creator":"@javacodegeeks","twitter_site":"@javacodegeeks","twitter_misc":{"Written by":"Andrey Redko","Est. reading time":"10 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.javacodegeeks.com\/2019\/08\/testing-spring-boot-conditionals-sane-way.html#article","isPartOf":{"@id":"https:\/\/www.javacodegeeks.com\/2019\/08\/testing-spring-boot-conditionals-sane-way.html"},"author":{"name":"Andrey Redko","@id":"https:\/\/www.javacodegeeks.com\/#\/schema\/person\/771a6504862edc45322776832cbce413"},"headline":"Testing Spring Boot conditionals the sane way","datePublished":"2019-08-07T04:00:50+00:00","dateModified":"2019-08-08T06:06:26+00:00","mainEntityOfPage":{"@id":"https:\/\/www.javacodegeeks.com\/2019\/08\/testing-spring-boot-conditionals-sane-way.html"},"wordCount":710,"commentCount":0,"publisher":{"@id":"https:\/\/www.javacodegeeks.com\/#organization"},"image":{"@id":"https:\/\/www.javacodegeeks.com\/2019\/08\/testing-spring-boot-conditionals-sane-way.html#primaryimage"},"thumbnailUrl":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2012\/10\/spring-logo.jpg","keywords":["JUnit","Maven","Spring Boot","Testing"],"articleSection":["Enterprise Java"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.javacodegeeks.com\/2019\/08\/testing-spring-boot-conditionals-sane-way.html#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.javacodegeeks.com\/2019\/08\/testing-spring-boot-conditionals-sane-way.html","url":"https:\/\/www.javacodegeeks.com\/2019\/08\/testing-spring-boot-conditionals-sane-way.html","name":"Testing Spring Boot conditionals the sane way - Java Code Geeks","isPartOf":{"@id":"https:\/\/www.javacodegeeks.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.javacodegeeks.com\/2019\/08\/testing-spring-boot-conditionals-sane-way.html#primaryimage"},"image":{"@id":"https:\/\/www.javacodegeeks.com\/2019\/08\/testing-spring-boot-conditionals-sane-way.html#primaryimage"},"thumbnailUrl":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2012\/10\/spring-logo.jpg","datePublished":"2019-08-07T04:00:50+00:00","dateModified":"2019-08-08T06:06:26+00:00","description":"Interested to learn about Spring Boot conditionals? Check our article explaining how to test spring boot whenbeans have to be injected conditionally","breadcrumb":{"@id":"https:\/\/www.javacodegeeks.com\/2019\/08\/testing-spring-boot-conditionals-sane-way.html#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.javacodegeeks.com\/2019\/08\/testing-spring-boot-conditionals-sane-way.html"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.javacodegeeks.com\/2019\/08\/testing-spring-boot-conditionals-sane-way.html#primaryimage","url":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2012\/10\/spring-logo.jpg","contentUrl":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2012\/10\/spring-logo.jpg","width":150,"height":150,"caption":"spring-interview-questions-answers"},{"@type":"BreadcrumbList","@id":"https:\/\/www.javacodegeeks.com\/2019\/08\/testing-spring-boot-conditionals-sane-way.html#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.javacodegeeks.com\/"},{"@type":"ListItem","position":2,"name":"Java","item":"https:\/\/www.javacodegeeks.com\/category\/java"},{"@type":"ListItem","position":3,"name":"Enterprise Java","item":"https:\/\/www.javacodegeeks.com\/category\/java\/enterprise-java"},{"@type":"ListItem","position":4,"name":"Testing Spring Boot conditionals the sane way"}]},{"@type":"WebSite","@id":"https:\/\/www.javacodegeeks.com\/#website","url":"https:\/\/www.javacodegeeks.com\/","name":"Java Code Geeks","description":"Java Developers Resource Center","publisher":{"@id":"https:\/\/www.javacodegeeks.com\/#organization"},"alternateName":"JCG","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.javacodegeeks.com\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/www.javacodegeeks.com\/#organization","name":"Exelixis Media P.C.","url":"https:\/\/www.javacodegeeks.com\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.javacodegeeks.com\/#\/schema\/logo\/image\/","url":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2022\/06\/exelixis-logo.png","contentUrl":"https:\/\/www.javacodegeeks.com\/wp-content\/uploads\/2022\/06\/exelixis-logo.png","width":864,"height":246,"caption":"Exelixis Media P.C."},"image":{"@id":"https:\/\/www.javacodegeeks.com\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/javacodegeeks","https:\/\/x.com\/javacodegeeks"]},{"@type":"Person","@id":"https:\/\/www.javacodegeeks.com\/#\/schema\/person\/771a6504862edc45322776832cbce413","name":"Andrey Redko","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/16419ce8394173028eddaeb992859862bab50cfcf74589fa9bb9a3dd8bb27518?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/16419ce8394173028eddaeb992859862bab50cfcf74589fa9bb9a3dd8bb27518?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/16419ce8394173028eddaeb992859862bab50cfcf74589fa9bb9a3dd8bb27518?s=96&d=mm&r=g","caption":"Andrey Redko"},"description":"Andriy is a well-grounded software developer with more then 12 years of practical experience using Java\/EE, C#\/.NET, C++, Groovy, Ruby, functional programming (Scala), databases (MySQL, PostgreSQL, Oracle) and NoSQL solutions (MongoDB, Redis).","sameAs":["http:\/\/aredko.blogspot.com\/","http:\/\/ca.linkedin.com\/in\/aredko"],"url":"https:\/\/www.javacodegeeks.com\/author\/andrey-redko"}]}},"_links":{"self":[{"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/posts\/94660","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/users\/141"}],"replies":[{"embeddable":true,"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/comments?post=94660"}],"version-history":[{"count":0,"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/posts\/94660\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/media\/240"}],"wp:attachment":[{"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/media?parent=94660"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/categories?post=94660"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.javacodegeeks.com\/wp-json\/wp\/v2\/tags?post=94660"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}