From 7f5823000ff05aa3aaf6b334e073c9db48568d3d Mon Sep 17 00:00:00 2001 From: Tim Ysewyn Date: Thu, 12 Sep 2019 19:19:00 +0200 Subject: [PATCH] Updated discovery auto configuration --- .../CommonsClientAutoConfiguration.java | 9 +- ...onalOnDiscoveryHealthIndicatorEnabled.java | 43 +++++++++ ...eactiveCommonsClientAutoConfiguration.java | 6 +- ...ositeDiscoveryClientAutoConfiguration.java | 3 - ...ctiveDiscoveryClientAutoConfiguration.java | 12 ++- .../CommonsClientAutoConfigurationTests.java | 90 ++++++++++--------- ...veCommonsClientAutoConfigurationTests.java | 70 +++++++++------ 7 files changed, 148 insertions(+), 85 deletions(-) create mode 100644 spring-cloud-commons/src/main/java/org/springframework/cloud/client/ConditionalOnDiscoveryHealthIndicatorEnabled.java diff --git a/spring-cloud-commons/src/main/java/org/springframework/cloud/client/CommonsClientAutoConfiguration.java b/spring-cloud-commons/src/main/java/org/springframework/cloud/client/CommonsClientAutoConfiguration.java index d3de269f..2c6b32a2 100644 --- a/spring-cloud-commons/src/main/java/org/springframework/cloud/client/CommonsClientAutoConfiguration.java +++ b/spring-cloud-commons/src/main/java/org/springframework/cloud/client/CommonsClientAutoConfiguration.java @@ -25,7 +25,6 @@ import org.springframework.boot.actuate.autoconfigure.endpoint.condition.Conditi import org.springframework.boot.actuate.endpoint.annotation.Endpoint; import org.springframework.boot.actuate.health.HealthAggregator; import org.springframework.boot.actuate.health.HealthIndicator; -import org.springframework.boot.autoconfigure.AutoConfigureOrder; import org.springframework.boot.autoconfigure.EnableAutoConfiguration; import org.springframework.boot.autoconfigure.condition.ConditionalOnBean; import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; @@ -50,21 +49,18 @@ import org.springframework.context.annotation.Configuration; * @author Tim Ysewyn */ @Configuration -@AutoConfigureOrder(0) public class CommonsClientAutoConfiguration { @Configuration @EnableConfigurationProperties(DiscoveryClientHealthIndicatorProperties.class) - @ConditionalOnClass(HealthIndicator.class) @ConditionalOnBean(DiscoveryClient.class) @ConditionalOnDiscoveryEnabled @ConditionalOnBlockingDiscoveryEnabled protected static class DiscoveryLoadBalancerConfiguration { @Bean - @ConditionalOnProperty( - value = "spring.cloud.discovery.client.health-indicator.enabled", - matchIfMissing = true) + @ConditionalOnClass(HealthIndicator.class) + @ConditionalOnDiscoveryHealthIndicatorEnabled public DiscoveryClientHealthIndicator discoveryClientHealthIndicator( ObjectProvider discoveryClient, DiscoveryClientHealthIndicatorProperties properties) { @@ -72,6 +68,7 @@ public class CommonsClientAutoConfiguration { } @Bean + @ConditionalOnClass(HealthIndicator.class) @ConditionalOnProperty( value = "spring.cloud.discovery.client.composite-indicator.enabled", matchIfMissing = true) diff --git a/spring-cloud-commons/src/main/java/org/springframework/cloud/client/ConditionalOnDiscoveryHealthIndicatorEnabled.java b/spring-cloud-commons/src/main/java/org/springframework/cloud/client/ConditionalOnDiscoveryHealthIndicatorEnabled.java new file mode 100644 index 00000000..09e4af9e --- /dev/null +++ b/spring-cloud-commons/src/main/java/org/springframework/cloud/client/ConditionalOnDiscoveryHealthIndicatorEnabled.java @@ -0,0 +1,43 @@ +/* + * Copyright 2019-2019 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.springframework.cloud.client; + +import java.lang.annotation.Documented; +import java.lang.annotation.ElementType; +import java.lang.annotation.Inherited; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; + +/** + * Provides a more succinct conditional + * spring.cloud.discovery.client.health-indicator.enabled. + * + * @since 2.2.0 + * @author Tim Ysewyn + */ +@Target({ ElementType.TYPE, ElementType.METHOD }) +@Retention(RetentionPolicy.RUNTIME) +@Documented +@Inherited +@ConditionalOnProperty(value = "spring.cloud.discovery.client.health-indicator.enabled", + matchIfMissing = true) +public @interface ConditionalOnDiscoveryHealthIndicatorEnabled { + +} diff --git a/spring-cloud-commons/src/main/java/org/springframework/cloud/client/ReactiveCommonsClientAutoConfiguration.java b/spring-cloud-commons/src/main/java/org/springframework/cloud/client/ReactiveCommonsClientAutoConfiguration.java index 44ca9839..dbaad4cf 100644 --- a/spring-cloud-commons/src/main/java/org/springframework/cloud/client/ReactiveCommonsClientAutoConfiguration.java +++ b/spring-cloud-commons/src/main/java/org/springframework/cloud/client/ReactiveCommonsClientAutoConfiguration.java @@ -18,8 +18,7 @@ package org.springframework.cloud.client; import java.util.Collection; -import org.springframework.boot.actuate.health.HealthIndicator; -import org.springframework.boot.autoconfigure.AutoConfigureOrder; +import org.springframework.boot.actuate.health.ReactiveHealthIndicator; import org.springframework.boot.autoconfigure.EnableAutoConfiguration; import org.springframework.boot.autoconfigure.condition.ConditionalOnBean; import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; @@ -42,18 +41,17 @@ import org.springframework.context.annotation.Configuration; * @since 2.2.0 */ @Configuration -@AutoConfigureOrder(0) public class ReactiveCommonsClientAutoConfiguration { @Configuration @EnableConfigurationProperties(DiscoveryClientHealthIndicatorProperties.class) - @ConditionalOnClass(HealthIndicator.class) @ConditionalOnBean(ReactiveDiscoveryClient.class) @ConditionalOnDiscoveryEnabled @ConditionalOnReactiveDiscoveryEnabled protected static class ReactiveDiscoveryLoadBalancerConfiguration { @Bean + @ConditionalOnClass(ReactiveHealthIndicator.class) @ConditionalOnProperty( value = "spring.cloud.discovery.client.composite-indicator.enabled", matchIfMissing = true) diff --git a/spring-cloud-commons/src/main/java/org/springframework/cloud/client/discovery/composite/reactive/ReactiveCompositeDiscoveryClientAutoConfiguration.java b/spring-cloud-commons/src/main/java/org/springframework/cloud/client/discovery/composite/reactive/ReactiveCompositeDiscoveryClientAutoConfiguration.java index b6a0c0ac..1cae8b7f 100644 --- a/spring-cloud-commons/src/main/java/org/springframework/cloud/client/discovery/composite/reactive/ReactiveCompositeDiscoveryClientAutoConfiguration.java +++ b/spring-cloud-commons/src/main/java/org/springframework/cloud/client/discovery/composite/reactive/ReactiveCompositeDiscoveryClientAutoConfiguration.java @@ -18,11 +18,9 @@ package org.springframework.cloud.client.discovery.composite.reactive; import java.util.List; -import org.springframework.boot.autoconfigure.AutoConfigureBefore; import org.springframework.cloud.client.ConditionalOnDiscoveryEnabled; import org.springframework.cloud.client.ConditionalOnReactiveDiscoveryEnabled; import org.springframework.cloud.client.discovery.ReactiveDiscoveryClient; -import org.springframework.cloud.client.discovery.simple.reactive.SimpleReactiveDiscoveryClientAutoConfiguration; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Primary; @@ -36,7 +34,6 @@ import org.springframework.context.annotation.Primary; @Configuration @ConditionalOnDiscoveryEnabled @ConditionalOnReactiveDiscoveryEnabled -@AutoConfigureBefore(SimpleReactiveDiscoveryClientAutoConfiguration.class) public class ReactiveCompositeDiscoveryClientAutoConfiguration { @Bean diff --git a/spring-cloud-commons/src/main/java/org/springframework/cloud/client/discovery/simple/reactive/SimpleReactiveDiscoveryClientAutoConfiguration.java b/spring-cloud-commons/src/main/java/org/springframework/cloud/client/discovery/simple/reactive/SimpleReactiveDiscoveryClientAutoConfiguration.java index f5681a15..2b56f86e 100644 --- a/spring-cloud-commons/src/main/java/org/springframework/cloud/client/discovery/simple/reactive/SimpleReactiveDiscoveryClientAutoConfiguration.java +++ b/spring-cloud-commons/src/main/java/org/springframework/cloud/client/discovery/simple/reactive/SimpleReactiveDiscoveryClientAutoConfiguration.java @@ -20,14 +20,18 @@ import java.net.URI; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; +import org.springframework.boot.actuate.health.ReactiveHealthIndicator; +import org.springframework.boot.autoconfigure.AutoConfigureAfter; import org.springframework.boot.autoconfigure.AutoConfigureBefore; -import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; +import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; import org.springframework.boot.autoconfigure.web.ServerProperties; import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.boot.web.context.WebServerInitializedEvent; import org.springframework.cloud.client.ConditionalOnDiscoveryEnabled; +import org.springframework.cloud.client.ConditionalOnDiscoveryHealthIndicatorEnabled; import org.springframework.cloud.client.ConditionalOnReactiveDiscoveryEnabled; import org.springframework.cloud.client.ReactiveCommonsClientAutoConfiguration; +import org.springframework.cloud.client.discovery.composite.reactive.ReactiveCompositeDiscoveryClientAutoConfiguration; import org.springframework.cloud.client.discovery.health.DiscoveryClientHealthIndicatorProperties; import org.springframework.cloud.client.discovery.health.reactive.ReactiveDiscoveryClientHealthIndicator; import org.springframework.cloud.commons.util.InetUtils; @@ -47,6 +51,7 @@ import org.springframework.core.annotation.Order; @ConditionalOnReactiveDiscoveryEnabled @EnableConfigurationProperties(DiscoveryClientHealthIndicatorProperties.class) @AutoConfigureBefore(ReactiveCommonsClientAutoConfiguration.class) +@AutoConfigureAfter(ReactiveCompositeDiscoveryClientAutoConfiguration.class) public class SimpleReactiveDiscoveryClientAutoConfiguration implements ApplicationListener { @@ -78,9 +83,8 @@ public class SimpleReactiveDiscoveryClientAutoConfiguration } @Bean - @ConditionalOnProperty( - value = "spring.cloud.discovery.client.health-indicator.enabled", - matchIfMissing = true) + @ConditionalOnClass(ReactiveHealthIndicator.class) + @ConditionalOnDiscoveryHealthIndicatorEnabled public ReactiveDiscoveryClientHealthIndicator simpleReactiveDiscoveryClientHealthIndicator( DiscoveryClientHealthIndicatorProperties properties) { return new ReactiveDiscoveryClientHealthIndicator(simpleReactiveDiscoveryClient(), diff --git a/spring-cloud-commons/src/test/java/org/springframework/cloud/client/CommonsClientAutoConfigurationTests.java b/spring-cloud-commons/src/test/java/org/springframework/cloud/client/CommonsClientAutoConfigurationTests.java index 0da31750..5176d2ab 100644 --- a/spring-cloud-commons/src/test/java/org/springframework/cloud/client/CommonsClientAutoConfigurationTests.java +++ b/spring-cloud-commons/src/test/java/org/springframework/cloud/client/CommonsClientAutoConfigurationTests.java @@ -18,9 +18,9 @@ package org.springframework.cloud.client; import org.junit.Test; -import org.springframework.beans.BeansException; import org.springframework.boot.actuate.autoconfigure.health.HealthEndpointAutoConfiguration; import org.springframework.boot.autoconfigure.AutoConfigurations; +import org.springframework.boot.test.context.FilteredClassLoader; import org.springframework.boot.test.context.TestConfiguration; import org.springframework.boot.test.context.runner.ApplicationContextRunner; import org.springframework.cloud.client.actuator.FeaturesEndpoint; @@ -29,12 +29,9 @@ import org.springframework.cloud.client.discovery.health.DiscoveryClientHealthIn import org.springframework.cloud.client.discovery.health.DiscoveryCompositeHealthIndicator; import org.springframework.cloud.client.discovery.simple.SimpleDiscoveryClientAutoConfiguration; import org.springframework.cloud.commons.util.UtilAutoConfiguration; -import org.springframework.context.ConfigurableApplicationContext; import org.springframework.context.annotation.Bean; -import org.springframework.context.annotation.Configuration; import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.Assertions.fail; import static org.assertj.core.api.BDDAssertions.then; /** @@ -45,31 +42,35 @@ import static org.assertj.core.api.BDDAssertions.then; public class CommonsClientAutoConfigurationTests { ApplicationContextRunner applicationContextRunner = new ApplicationContextRunner() - .withConfiguration( - AutoConfigurations.of(HealthEndpointAutoConfiguration.class, - CommonsClientAutoConfiguration.class, - SimpleDiscoveryClientAutoConfiguration.class, - UtilAutoConfiguration.class)); + .withConfiguration(AutoConfigurations.of(CommonsClientAutoConfiguration.class, + SimpleDiscoveryClientAutoConfiguration.class, + UtilAutoConfiguration.class)); @Test public void beansCreatedNormally() { - applicationContextRunner.run(ctxt -> { - then(ctxt.getBean(DiscoveryClientHealthIndicator.class)).isNotNull(); - then(ctxt.getBean(DiscoveryCompositeHealthIndicator.class)).isNotNull(); - then(ctxt.getBean(FeaturesEndpoint.class)).isNotNull(); - then(ctxt.getBeansOfType(HasFeatures.class).values()).isNotEmpty(); - }); + applicationContextRunner + .withConfiguration( + AutoConfigurations.of(HealthEndpointAutoConfiguration.class)) + .run(ctxt -> { + then(ctxt.getBean(DiscoveryClientHealthIndicator.class)).isNotNull(); + then(ctxt.getBean(DiscoveryCompositeHealthIndicator.class)) + .isNotNull(); + then(ctxt.getBean(FeaturesEndpoint.class)).isNotNull(); + then(ctxt.getBeansOfType(HasFeatures.class).values()).isNotEmpty(); + }); } @Test public void disableAll() { applicationContextRunner .withPropertyValues("spring.cloud.discovery.enabled=false").run(ctxt -> { - assertBeanNonExistant(ctxt, DiscoveryClientHealthIndicator.class); - assertBeanNonExistant(ctxt, DiscoveryCompositeHealthIndicator.class); + assertThat(ctxt) + .doesNotHaveBean(DiscoveryClientHealthIndicator.class); + assertThat(ctxt) + .doesNotHaveBean(DiscoveryCompositeHealthIndicator.class); then(ctxt.getBean(FeaturesEndpoint.class)).isNotNull(); // features actuator is independent of discovery - assertBeanNonExistant(ctxt, HasFeatures.class); + assertThat(ctxt).doesNotHaveBean(HasFeatures.class); }); } @@ -78,11 +79,13 @@ public class CommonsClientAutoConfigurationTests { applicationContextRunner .withPropertyValues("spring.cloud.discovery.blocking.enabled=false") .run(ctxt -> { - assertBeanNonExistant(ctxt, DiscoveryClientHealthIndicator.class); - assertBeanNonExistant(ctxt, DiscoveryCompositeHealthIndicator.class); + assertThat(ctxt) + .doesNotHaveBean(DiscoveryClientHealthIndicator.class); + assertThat(ctxt) + .doesNotHaveBean(DiscoveryCompositeHealthIndicator.class); then(ctxt.getBean(FeaturesEndpoint.class)).isNotNull(); // features actuator is independent of discovery - assertBeanNonExistant(ctxt, HasFeatures.class); + assertThat(ctxt).doesNotHaveBean(HasFeatures.class); }); } @@ -92,9 +95,11 @@ public class CommonsClientAutoConfigurationTests { "spring.cloud.discovery.client.health-indicator.enabled=false", "spring.cloud.discovery.client.composite-indicator.enabled=false", "spring.cloud.features.enabled=false").run(ctxt -> { - assertBeanNonExistant(ctxt, DiscoveryClientHealthIndicator.class); - assertBeanNonExistant(ctxt, DiscoveryCompositeHealthIndicator.class); - assertBeanNonExistant(ctxt, FeaturesEndpoint.class); + assertThat(ctxt) + .doesNotHaveBean(DiscoveryClientHealthIndicator.class); + assertThat(ctxt) + .doesNotHaveBean(DiscoveryCompositeHealthIndicator.class); + assertThat(ctxt).doesNotHaveBean(FeaturesEndpoint.class); }); } @@ -104,8 +109,24 @@ public class CommonsClientAutoConfigurationTests { .withPropertyValues( "spring.cloud.discovery.client.health-indicator.enabled=false") .run(ctxt -> { - assertBeanNonExistant(ctxt, DiscoveryClientHealthIndicator.class); - assertBeanNonExistant(ctxt, DiscoveryCompositeHealthIndicator.class); + assertThat(ctxt) + .doesNotHaveBean(DiscoveryClientHealthIndicator.class); + assertThat(ctxt) + .doesNotHaveBean(DiscoveryCompositeHealthIndicator.class); + }); + } + + @Test + public void worksWithoutActuator() { + applicationContextRunner + .withClassLoader( + new FilteredClassLoader("org.springframework.boot.actuate")) + .run(context -> { + assertThat(context) + .doesNotHaveBean(DiscoveryClientHealthIndicator.class); + assertThat(context) + .doesNotHaveBean(DiscoveryCompositeHealthIndicator.class); + then(context.getBeansOfType(HasFeatures.class).values()).isNotEmpty(); }); } @@ -113,7 +134,7 @@ public class CommonsClientAutoConfigurationTests { public void conditionalOnDiscoveryEnabledWorks() { applicationContextRunner.withUserConfiguration(DiscoveryEnabledConfig.class) .withPropertyValues("spring.cloud.discovery.enabled=false") - .run(context -> assertBeanNonExistant(context, TestBean.class)); + .run(context -> assertThat(context).doesNotHaveBean(TestBean.class)); applicationContextRunner.withUserConfiguration(DiscoveryEnabledConfig.class) .withPropertyValues("spring.cloud.discovery.enabled=true") .run(context -> assertThat(context.getBean(TestBean.class)).isNotNull()); @@ -124,25 +145,14 @@ public class CommonsClientAutoConfigurationTests { applicationContextRunner .withUserConfiguration(BlockingDiscoveryEnabledConfig.class) .withPropertyValues("spring.cloud.discovery.blocking.enabled=false") - .run(context -> assertBeanNonExistant(context, TestBean.class)); + .run(context -> assertThat(context).doesNotHaveBean(TestBean.class)); applicationContextRunner .withUserConfiguration(BlockingDiscoveryEnabledConfig.class) .withPropertyValues("spring.cloud.discovery.blocking.enabled=true") .run(context -> assertThat(context.getBean(TestBean.class)).isNotNull()); } - private void assertBeanNonExistant(ConfigurableApplicationContext ctxt, - Class beanClass) { - try { - ctxt.getBean(beanClass); - fail("Bean of type " + beanClass + " should not have been created"); - } - catch (BeansException e) { - // should fail with exception - } - } - - @Configuration + @TestConfiguration @ConditionalOnDiscoveryEnabled protected static class DiscoveryEnabledConfig { diff --git a/spring-cloud-commons/src/test/java/org/springframework/cloud/client/ReactiveCommonsClientAutoConfigurationTests.java b/spring-cloud-commons/src/test/java/org/springframework/cloud/client/ReactiveCommonsClientAutoConfigurationTests.java index 3ededeff..3dea6b9f 100644 --- a/spring-cloud-commons/src/test/java/org/springframework/cloud/client/ReactiveCommonsClientAutoConfigurationTests.java +++ b/spring-cloud-commons/src/test/java/org/springframework/cloud/client/ReactiveCommonsClientAutoConfigurationTests.java @@ -18,8 +18,8 @@ package org.springframework.cloud.client; import org.junit.Test; -import org.springframework.beans.BeansException; import org.springframework.boot.autoconfigure.AutoConfigurations; +import org.springframework.boot.test.context.FilteredClassLoader; import org.springframework.boot.test.context.TestConfiguration; import org.springframework.boot.test.context.runner.ApplicationContextRunner; import org.springframework.cloud.client.actuator.FeaturesEndpoint; @@ -28,12 +28,9 @@ import org.springframework.cloud.client.discovery.health.reactive.ReactiveDiscov import org.springframework.cloud.client.discovery.health.reactive.ReactiveDiscoveryCompositeHealthContributor; import org.springframework.cloud.client.discovery.simple.reactive.SimpleReactiveDiscoveryClientAutoConfiguration; import org.springframework.cloud.commons.util.UtilAutoConfiguration; -import org.springframework.context.ConfigurableApplicationContext; import org.springframework.context.annotation.Bean; -import org.springframework.context.annotation.Configuration; import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.Assertions.fail; import static org.assertj.core.api.BDDAssertions.then; /** @@ -64,13 +61,13 @@ public class ReactiveCommonsClientAutoConfigurationTests { applicationContextRunner .withPropertyValues("spring.cloud.discovery.enabled=false") .run(context -> { - assertBeanNonExistant(context, + assertThat(context).doesNotHaveBean( ReactiveDiscoveryClientHealthIndicator.class); - assertBeanNonExistant(context, + assertThat(context).doesNotHaveBean( ReactiveDiscoveryCompositeHealthContributor.class); // features actuator is independent of discovery then(context.getBean(FeaturesEndpoint.class)).isNotNull(); - assertBeanNonExistant(context, HasFeatures.class); + assertThat(context).doesNotHaveBean(HasFeatures.class); }); } @@ -79,13 +76,13 @@ public class ReactiveCommonsClientAutoConfigurationTests { applicationContextRunner .withPropertyValues("spring.cloud.discovery.reactive.enabled=false") .run(context -> { - assertBeanNonExistant(context, + assertThat(context).doesNotHaveBean( ReactiveDiscoveryClientHealthIndicator.class); - assertBeanNonExistant(context, + assertThat(context).doesNotHaveBean( ReactiveDiscoveryCompositeHealthContributor.class); // features actuator is independent of discovery then(context.getBean(FeaturesEndpoint.class)).isNotNull(); - assertBeanNonExistant(context, HasFeatures.class); + assertThat(context).doesNotHaveBean(HasFeatures.class); }); } @@ -95,11 +92,11 @@ public class ReactiveCommonsClientAutoConfigurationTests { "spring.cloud.discovery.client.health-indicator.enabled=false", "spring.cloud.discovery.client.composite-indicator.enabled=false", "spring.cloud.features.enabled=false").run(context -> { - assertBeanNonExistant(context, + assertThat(context).doesNotHaveBean( ReactiveDiscoveryClientHealthIndicator.class); - assertBeanNonExistant(context, + assertThat(context).doesNotHaveBean( ReactiveDiscoveryCompositeHealthContributor.class); - assertBeanNonExistant(context, FeaturesEndpoint.class); + assertThat(context).doesNotHaveBean(FeaturesEndpoint.class); }); } @@ -109,35 +106,52 @@ public class ReactiveCommonsClientAutoConfigurationTests { .withPropertyValues( "spring.cloud.discovery.client.health-indicator.enabled=false") .run(context -> { - assertBeanNonExistant(context, + assertThat(context).doesNotHaveBean( ReactiveDiscoveryClientHealthIndicator.class); - assertBeanNonExistant(context, + assertThat(context).doesNotHaveBean( ReactiveDiscoveryCompositeHealthContributor.class); }); } + @Test + public void worksWithoutActuator() { + applicationContextRunner + .withClassLoader( + new FilteredClassLoader("org.springframework.boot.actuate")) + .run(context -> { + assertThat(context).doesNotHaveBean( + ReactiveDiscoveryClientHealthIndicator.class); + assertThat(context).doesNotHaveBean( + ReactiveDiscoveryCompositeHealthContributor.class); + then(context.getBeansOfType(HasFeatures.class).values()).isNotEmpty(); + }); + } + + @Test + public void worksWithoutWebflux() { + applicationContextRunner + .withClassLoader( + new FilteredClassLoader("org.springframework.web.reactive")) + .run(context -> { + assertThat(context).doesNotHaveBean( + ReactiveDiscoveryClientHealthIndicator.class); + assertThat(context).doesNotHaveBean( + ReactiveDiscoveryCompositeHealthContributor.class); + assertThat(context).doesNotHaveBean(HasFeatures.class); + }); + } + @Test public void conditionalOnReactiveDiscoveryEnabledWorks() { ApplicationContextRunner contextRunner = new ApplicationContextRunner() .withUserConfiguration(ReactiveDiscoveryEnabledConfig.class); contextRunner.withPropertyValues("spring.cloud.discovery.reactive.enabled=false") - .run(context -> assertBeanNonExistant(context, TestBean.class)); + .run(context -> assertThat(context).doesNotHaveBean(TestBean.class)); contextRunner.withPropertyValues("spring.cloud.discovery.reactive.enabled=true") .run(context -> assertThat(context.getBean(TestBean.class)).isNotNull()); } - private void assertBeanNonExistant(ConfigurableApplicationContext ctxt, - Class beanClass) { - try { - ctxt.getBean(beanClass); - fail("Bean of type " + beanClass + " should not have been created"); - } - catch (BeansException e) { - // should fail with exception - } - } - - @Configuration + @TestConfiguration @ConditionalOnDiscoveryEnabled protected static class DiscoveryEnabledConfig {