org.springframework.boot.test.context.FilteredClassLoader Java Examples

@Test
void configurationOfRepositoryTypeShouldWork() {
	this.contextRunner
		.withPropertyValues("spring.data.neo4j.repositories.type=none")
		.withUserConfiguration(TestConfiguration.class)
		.withClassLoader(new FilteredClassLoader(Flux.class))
		.run(ctx ->
			assertThat(ctx)
				.doesNotHaveBean(Neo4jTransactionManager.class)
				.doesNotHaveBean(ReactiveNeo4jClient.class)
				.doesNotHaveBean(Neo4jRepository.class)
		);

	this.contextRunner
		.withPropertyValues("spring.data.neo4j.repositories.type=imperative")
		.withUserConfiguration(TestConfiguration.class)
		.run(ctx ->
			assertThat(ctx)
				.hasSingleBean(Neo4jTransactionManager.class)
				.hasSingleBean(Neo4jClient.class)
				.doesNotHaveBean(ReactiveNeo4jRepository.class)
		);
}
 

@Test
public void testPostgre() {
	this.contextRunner.withPropertyValues(
			"spring.cloud.gcp.sql.instanceConnectionName=tubular-bells:singapore:test-instance")
			.withClassLoader(
					new FilteredClassLoader("com.google.cloud.sql.mysql"))
			.run((context) -> {
				CloudSqlJdbcInfoProvider urlProvider =
						context.getBean(CloudSqlJdbcInfoProvider.class);
				assertThat(urlProvider.getJdbcUrl()).isEqualTo(
						"jdbc:postgresql://google/test-database?"
								+ "socketFactory=com.google.cloud.sql.postgres.SocketFactory"
								+ "&cloudSqlInstance=tubular-bells:singapore:test-instance");
				assertThat(urlProvider.getJdbcDriverClass()).matches("org.postgresql.Driver");
			});
}
 

@Test
public void worksWithoutSpringWeb() {
	applicationContextRunner
			.withClassLoader(new FilteredClassLoader(RestTemplate.class))
			.run(context -> {
				assertThat(context).doesNotHaveBean(BlockingLoadBalancerClient.class);
			});
}
 

@Test
public void shouldConfigureForNoOpWhenMissingImplementation() {
	this.contextRunner
			.withClassLoader(new FilteredClassLoader(org.apache.camel.Message.class,
					org.springframework.messaging.Message.class, JmsTemplate.class,
					KafkaTemplate.class, RabbitTemplate.class, EnableBinding.class))
			.run((context) -> {
				assertThat(context.getBeansOfType(MessageVerifierSender.class))
						.hasSize(1);
				assertThat(context.getBeansOfType(NoOpStubMessages.class)).hasSize(1);
			});
}
 

@Test
public void shouldNotConfigureIfHttpClientIsMissing() {

	this.contextRunner.withUserConfiguration(AuthenticationFactoryConfiguration.class)
			.withClassLoader(
					new FilteredClassLoader("reactor.netty.http.client.HttpClient"))
			.run(context -> {

				assertThat(context.getBeanNamesForType(ReactiveVaultOperations.class))
						.isEmpty();
			});
}
 

@Test
public void withEntityManagerFactoryBeanAndMissingSpringProcessEngineConfigurationClass() {
    contextRunner
        .withConfiguration(AutoConfigurations.of(
            DataSourceAutoConfiguration.class,
            HibernateJpaAutoConfiguration.class
        ))
        .withClassLoader(new FilteredClassLoader(SpringProcessEngineConfiguration.class))
        .run(context -> {
            assertThat(context).doesNotHaveBean(FlowableJpaAutoConfiguration.class);
        });
}
 

@Test
public void withMissingAuthenticationManager() {
    contextRunner
        .withConfiguration(IDM_CONFIGURATION)
        .withClassLoader(new FilteredClassLoader(AuthenticationManager.class))
        .run(context -> assertThat(context)
            .hasSingleBean(IdmIdentityService.class)
            .doesNotHaveBean(FlowableSecurityAutoConfiguration.class));
}
 

@Test
public void withMissingIdmIdentityService() {
    contextRunner
        .withConfiguration(IDM_CONFIGURATION)
        .withClassLoader(new FilteredClassLoader(IdmIdentityService.class))
        .run(context -> assertThat(context)
            .hasSingleBean(IdmIdentityService.class)
            .doesNotHaveBean(FlowableSecurityAutoConfiguration.class));
}
 

@Test
public void withMissingFlowableUserDetailsService() {
    contextRunner
        .withConfiguration(IDM_CONFIGURATION)
        .withClassLoader(new FilteredClassLoader(FlowableUserDetailsService.class))
        .run(context -> assertThat(context)
            .hasSingleBean(IdmIdentityService.class)
            .doesNotHaveBean(FlowableSecurityAutoConfiguration.class));
}
 

@Test
void should_apply_in_memory_metrics_when_meter_registry_class_missing() {
	this.contextRunner.withClassLoader(new FilteredClassLoader(MeterRegistry.class))
			.run((context) -> {
				ReporterMetrics bean = context.getBean(ReporterMetrics.class);

				BDDAssertions.then(bean).isInstanceOf(InMemoryReporterMetrics.class);
			});
}
 

@Test
void shoud_not_create_TraceSchedulingAspect_without_aspectJ() {
	this.contextRunner
			.withClassLoader(new FilteredClassLoader(ProceedingJoinPoint.class))
			.run(context -> assertThat(context)
					.doesNotHaveBean(TraceSchedulingAspect.class));
}
 

@Test
public void worksWithoutWebflux() {
	contextRunner
			.withClassLoader(
					new FilteredClassLoader("org.springframework.web.reactive"))
			.run(context -> {
				assertThat(context).doesNotHaveBean(ReactiveDiscoveryClient.class);
				assertThat(context).doesNotHaveBean(
						ReactiveDiscoveryClientHealthIndicator.class);
			});
}
 

@Test
public void worksWithoutActuator() {
	contextRunner
			.withClassLoader(
					new FilteredClassLoader("org.springframework.boot.actuate"))
			.run(context -> {
				assertThat(context).hasSingleBean(ReactiveDiscoveryClient.class);
				assertThat(context).doesNotHaveBean(
						ReactiveDiscoveryClientHealthIndicator.class);
			});
}
 

@Test
public void testKafkaBinderMetricsWhenNoMicrometer() {
	new ApplicationContextRunner().withUserConfiguration(KafkaMetricsTestConfig.class)
			.withClassLoader(new FilteredClassLoader("io.micrometer.core"))
			.run(context -> {
				assertThat(context.getBeanNamesForType(MeterRegistry.class))
						.isEmpty();
				assertThat(context.getBeanNamesForType(MeterBinder.class)).isEmpty();

				DirectFieldAccessor channelBindingServiceAccessor = new DirectFieldAccessor(
						context.getBean(BindingService.class));
				@SuppressWarnings("unchecked")
				Map<String, List<Binding<MessageChannel>>> consumerBindings =
					(Map<String, List<Binding<MessageChannel>>>) channelBindingServiceAccessor
						.getPropertyValue("consumerBindings");
				assertThat(new DirectFieldAccessor(
						consumerBindings.get("input").get(0)).getPropertyValue(
								"lifecycle.messageListenerContainer.beanName"))
										.isEqualTo("setByCustomizer:input");
				assertThat(new DirectFieldAccessor(
						consumerBindings.get("input").get(0)).getPropertyValue(
								"lifecycle.beanName"))
										.isEqualTo("setByCustomizer:input");
				assertThat(new DirectFieldAccessor(
						consumerBindings.get("source").get(0)).getPropertyValue(
								"lifecycle.beanName"))
										.isEqualTo("setByCustomizer:source");

				@SuppressWarnings("unchecked")
				Map<String, Binding<MessageChannel>> producerBindings =
					(Map<String, Binding<MessageChannel>>) channelBindingServiceAccessor
						.getPropertyValue("producerBindings");

				assertThat(new DirectFieldAccessor(
						producerBindings.get("output")).getPropertyValue(
						"lifecycle.beanName"))
						.isEqualTo("setByCustomizer:output");
			});
}
 

@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()).isEmpty();
			});
}
 

@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 worksWithoutActuator() {
	applicationContextRunner
			.withClassLoader(
					new FilteredClassLoader("org.springframework.boot.actuate"))
			.run(context -> {
				assertThat(context)
						.doesNotHaveBean(DiscoveryClientHealthIndicator.class);
				assertThat(context)
						.doesNotHaveBean(DiscoveryCompositeHealthContributor.class);
				then(context.getBeansOfType(HasFeatures.class).values()).isEmpty();
			});
}
 

@Test
public void worksWithoutWebflux() {
	contextRunner
			.withClassLoader(
					new FilteredClassLoader("org.springframework.web.reactive"))
			.run(context -> {
				assertThat(context).doesNotHaveBean(ReactiveDiscoveryClient.class);
				assertThat(context).doesNotHaveBean(
						ReactiveDiscoveryClientHealthIndicator.class);
			});
}
 

@Test
public void worksWithoutActuator() {
	contextRunner
			.withClassLoader(
					new FilteredClassLoader("org.springframework.boot.actuate"))
			.run(context -> {
				assertThat(context).hasSingleBean(ReactiveDiscoveryClient.class);
				assertThat(context).doesNotHaveBean(
						ReactiveDiscoveryClientHealthIndicator.class);
			});
}
 

@Test
public void worksWithoutWebflux() {
	contextRunner
			.withClassLoader(
					new FilteredClassLoader("org.springframework.web.reactive"))
			.run(context -> {
				assertThat(context).doesNotHaveBean(ReactiveDiscoveryClient.class);
				assertThat(context).doesNotHaveBean(
						ReactiveDiscoveryClientHealthIndicator.class);
			});
}
 

@Test
public void worksWithoutActuator() {
	contextRunner
			.withClassLoader(
					new FilteredClassLoader("org.springframework.boot.actuate"))
			.run(context -> {
				assertThat(context).hasSingleBean(ReactiveDiscoveryClient.class);
				assertThat(context).doesNotHaveBean(
						ReactiveDiscoveryClientHealthIndicator.class);
			});
}
 

@Test
public void worksWithoutWebflux() {
	contextRunner
			.withClassLoader(
					new FilteredClassLoader("org.springframework.web.reactive"))
			.run(context -> {
				assertThat(context)
						.doesNotHaveBean(CloudFoundryReactiveHeartbeatSender.class);
				assertThat(context).doesNotHaveBean(ReactiveDiscoveryClient.class);
				assertThat(context).doesNotHaveBean(
						ReactiveDiscoveryClientHealthIndicator.class);
			});
}
 

@Test
public void worksWithoutActuator() {
	contextRunner
			.withClassLoader(
					new FilteredClassLoader("org.springframework.boot.actuate"))
			.run(context -> {
				assertThat(context)
						.hasSingleBean(CloudFoundryReactiveHeartbeatSender.class);
				assertThat(context).hasSingleBean(ReactiveDiscoveryClient.class);
				assertThat(context).doesNotHaveBean(
						ReactiveDiscoveryClientHealthIndicator.class);
			});
}
 

@Test
public void whenDependentClassIsNotPresent_thenBeanMissing() {
    this.contextRunner.withUserConfiguration(ConditionalOnClassConfiguration.class)
        .withClassLoader(new FilteredClassLoader(ConditionalOnClassIntegrationTest.class))
        .run((context) -> {
            assertThat(context).doesNotHaveBean("created");
            assertThat(context).doesNotHaveBean(ConditionalOnClassIntegrationTest.class);

        });
}
 

@Test
public void whenDependentClassIsNotPresent_thenBeanCreated() {
    this.contextRunner.withUserConfiguration(ConditionalOnMissingClassConfiguration.class)
        .withClassLoader(new FilteredClassLoader(ConditionalOnClassIntegrationTest.class))
        .run((context) -> {
            assertThat(context).hasBean("missed");
            assertThat(context).getBean("missed")
                .isEqualTo("This is missed when ConditionalOnClassIntegrationTest is present on the classpath");
            assertThat(context).doesNotHaveBean(ConditionalOnClassIntegrationTest.class);

        });
}
 

@Test
void servicesAreNotCreatedWithoutLoggingOnClasspath() {
	contextRunner
		.withClassLoader(new FilteredClassLoader(ApplicationLogStreamPublisher.class))
		.withUserConfiguration(LoggingConfiguration.class)
		.run(context -> assertThat(context)
			.doesNotHaveBean(StreamingLogWebSocketHandler.class)
			.doesNotHaveBean(WebSocketHandlerAdapter.class)
			.doesNotHaveBean(HandlerMapping.class)
			.doesNotHaveBean(LogStreamPublisher.class)
			.doesNotHaveBean(ApplicationLogStreamPublisher.class));
}
 

@Test
@DisplayName("Should require all needed classes")
void shouldRequireAllNeededClasses() {
	contextRunner
		.withClassLoader(
			new FilteredClassLoader(Neo4jTransactionManager.class, PlatformTransactionManager.class))
		.run(ctx -> assertThat(ctx)
			.doesNotHaveBean(Neo4jClient.class)
			.doesNotHaveBean(Neo4jTemplate.class)
			.doesNotHaveBean(Neo4jTransactionManager.class)
		);
}
 

@Test
@DisplayName("Should require all needed classes")
void shouldRequireAllNeededClasses() {
	contextRunner
		.withClassLoader(
			new FilteredClassLoader(ReactiveNeo4jTransactionManager.class, ReactiveTransactionManager.class, Flux.class))
		.run(ctx -> assertThat(ctx)
			.doesNotHaveBean(ReactiveNeo4jClient.class)
			.doesNotHaveBean(ReactiveNeo4jTemplate.class)
			.doesNotHaveBean(ReactiveNeo4jTransactionManager.class)
		);
}
 

@Test
public void configurations_not_loaded_when_mvc_is_not_on_class_path() {
	contextRunner
			.withClassLoader(new FilteredClassLoader("org.springframework.web.context.support.GenericWebApplicationContext"))
			.run(context -> assertThat(context)
					.hasNotFailed()
					.doesNotHaveBean("openApiResource")
					.doesNotHaveBean("actuatorProvider")
					.doesNotHaveBean("multipleOpenApiResource")
			);

}
 

@Test
public void configurations_not_loaded_when_reactor_is_not_on_class_path() {
	contextRunner
			.withClassLoader(new FilteredClassLoader("org.springframework.web.reactive.HandlerResult"))
			.run(context -> assertThat(context)
					.hasNotFailed()
					.doesNotHaveBean("openApiResource"));

}