root
/
spring-boot
mirror of https://github.com/spring-projects/spring-boot.git
1
0
Fork 0
Code Issues Actions 15 Packages Projects Releases Wiki Activity

Improve the type-safety of ContextLoader for servlet and reactive web

This commit is contained in:
Andy Wilkinson 2017-07-02 15:08:09 +01:00 committed by Stephane Nicoll
parent 19ddfad63e
commit dd0ce54425
18 changed files with 1238 additions and 958 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
spring-boot-actuator/src/test/java/org/springframework/boot/actuate/autoconfigure/HealthIndicatorAutoConfigurationTests.java
View File

@ -58,6 +58,7 @@ import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.boot.test.context.ContextConsumer;
import org.springframework.boot.test.context.ContextLoader;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.cassandra.core.CassandraOperations;
@ -79,8 +80,9 @@ import static org.mockito.Mockito.mock;
*/
public class HealthIndicatorAutoConfigurationTests {
public final ContextLoader contextLoader = new ContextLoader().autoConfig(
HealthIndicatorAutoConfiguration.class, ManagementServerProperties.class);
public final ContextLoader<AnnotationConfigApplicationContext> contextLoader = ContextLoader
.standard().autoConfig(HealthIndicatorAutoConfiguration.class,
ManagementServerProperties.class);
@Test
public void defaultHealthIndicator() {
@ -378,7 +380,7 @@ public class HealthIndicatorAutoConfigurationTests {
.load(hasSingleHealthIndicator(ApplicationHealthIndicator.class));
}
private ContextConsumer hasSingleHealthIndicator(
private ContextConsumer<AnnotationConfigApplicationContext> hasSingleHealthIndicator(
Class<? extends HealthIndicator> type) {
return context -> {
Map<String, HealthIndicator> beans = context

579
spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/cache/CacheAutoConfigurationTests.java vendored
View File

@ -73,6 +73,7 @@ import org.springframework.cache.jcache.JCacheCacheManager;
import org.springframework.cache.support.NoOpCacheManager;
import org.springframework.cache.support.SimpleCacheManager;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
@ -100,8 +101,8 @@ public class CacheAutoConfigurationTests {
@Rule
public final ExpectedException thrown = ExpectedException.none();
private final ContextLoader contextLoader = new ContextLoader().autoConfig(
CacheAutoConfiguration.class);
private final ContextLoader<AnnotationConfigApplicationContext> contextLoader = ContextLoader
.standard().autoConfig(CacheAutoConfiguration.class);
@Test
public void noEnableCaching() {
@ -143,27 +144,27 @@ public class CacheAutoConfigurationTests {
public void customCacheResolverCanBeDefined() throws Exception {
this.contextLoader.config(SpecificCacheResolverConfiguration.class)
.env("spring.cache.type=simple").load(context -> {
validateCacheManager(context, ConcurrentMapCacheManager.class);
assertThat(context.getBeansOfType(CacheResolver.class)).hasSize(1);
});
validateCacheManager(context, ConcurrentMapCacheManager.class);
assertThat(context.getBeansOfType(CacheResolver.class)).hasSize(1);
});
}
@Test
public void notSupportedCachingMode() {
this.contextLoader.config(DefaultCacheConfiguration.class)
.env("spring.cache.type=foobar").loadAndFail(BeanCreationException.class,
ex -> assertThat(ex.getMessage()).contains(
"Failed to bind properties under 'spring.cache.type'"));
ex -> assertThat(ex.getMessage()).contains(
"Failed to bind properties under 'spring.cache.type'"));
}
@Test
public void simpleCacheExplicit() {
this.contextLoader.config(DefaultCacheConfiguration.class)
.env("spring.cache.type=simple").load(context -> {
ConcurrentMapCacheManager cacheManager = validateCacheManager(context,
ConcurrentMapCacheManager.class);
assertThat(cacheManager.getCacheNames()).isEmpty();
});
ConcurrentMapCacheManager cacheManager = validateCacheManager(context,
ConcurrentMapCacheManager.class);
assertThat(cacheManager.getCacheNames()).isEmpty();
});
}
@Test
@ -176,11 +177,12 @@ public class CacheAutoConfigurationTests {
public void simpleCacheExplicitWithCacheNames() {
this.contextLoader.config(DefaultCacheConfiguration.class)
.env("spring.cache.type=simple", "spring.cache.cacheNames[0]=foo",
"spring.cache.cacheNames[1]=bar").load(context -> {
ConcurrentMapCacheManager cacheManager = validateCacheManager(context,
ConcurrentMapCacheManager.class);
assertThat(cacheManager.getCacheNames()).containsOnly("foo", "bar");
});
"spring.cache.cacheNames[1]=bar")
.load(context -> {
ConcurrentMapCacheManager cacheManager = validateCacheManager(context,
ConcurrentMapCacheManager.class);
assertThat(cacheManager.getCacheNames()).containsOnly("foo", "bar");
});
}
@Test
@ -200,8 +202,8 @@ public class CacheAutoConfigurationTests {
public void genericCacheExplicit() {
this.contextLoader.config(DefaultCacheConfiguration.class)
.env("spring.cache.type=generic").loadAndFail(BeanCreationException.class,
ex -> assertThat(ex.getMessage()).contains(
"No cache manager could be auto-configured", "GENERIC"));
ex -> assertThat(ex.getMessage()).contains(
"No cache manager could be auto-configured", "GENERIC"));
}
@Test
@ -214,24 +216,24 @@ public class CacheAutoConfigurationTests {
public void genericCacheExplicitWithCaches() {
this.contextLoader.config(GenericCacheConfiguration.class)
.env("spring.cache.type=generic").load(context -> {
SimpleCacheManager cacheManager = validateCacheManager(context,
SimpleCacheManager.class);
assertThat(cacheManager.getCache("first"))
.isEqualTo(context.getBean("firstCache"));
assertThat(cacheManager.getCache("second"))
.isEqualTo(context.getBean("secondCache"));
assertThat(cacheManager.getCacheNames()).hasSize(2);
});
SimpleCacheManager cacheManager = validateCacheManager(context,
SimpleCacheManager.class);
assertThat(cacheManager.getCache("first"))
.isEqualTo(context.getBean("firstCache"));
assertThat(cacheManager.getCache("second"))
.isEqualTo(context.getBean("secondCache"));
assertThat(cacheManager.getCacheNames()).hasSize(2);
});
}
@Test
public void couchbaseCacheExplicit() {
this.contextLoader.config(CouchbaseCacheConfiguration.class)
.env("spring.cache.type=couchbase").load(context -> {
CouchbaseCacheManager cacheManager = validateCacheManager(context,
CouchbaseCacheManager.class);
assertThat(cacheManager.getCacheNames()).isEmpty();
});
CouchbaseCacheManager cacheManager = validateCacheManager(context,
CouchbaseCacheManager.class);
assertThat(cacheManager.getCacheNames()).isEmpty();
});
}
@Test
@ -244,44 +246,46 @@ public class CacheAutoConfigurationTests {
public void couchbaseCacheExplicitWithCaches() {
this.contextLoader.config(CouchbaseCacheConfiguration.class)
.env("spring.cache.type=couchbase", "spring.cache.cacheNames[0]=foo",
"spring.cache.cacheNames[1]=bar").load(context -> {
CouchbaseCacheManager cacheManager = validateCacheManager(context,
CouchbaseCacheManager.class);
assertThat(cacheManager.getCacheNames()).containsOnly("foo", "bar");
Cache cache = cacheManager.getCache("foo");
assertThat(cache).isInstanceOf(CouchbaseCache.class);
assertThat(((CouchbaseCache) cache).getTtl()).isEqualTo(0);
assertThat(((CouchbaseCache) cache).getNativeCache())
.isEqualTo(context.getBean("bucket"));
});
"spring.cache.cacheNames[1]=bar")
.load(context -> {
CouchbaseCacheManager cacheManager = validateCacheManager(context,
CouchbaseCacheManager.class);
assertThat(cacheManager.getCacheNames()).containsOnly("foo", "bar");
Cache cache = cacheManager.getCache("foo");
assertThat(cache).isInstanceOf(CouchbaseCache.class);
assertThat(((CouchbaseCache) cache).getTtl()).isEqualTo(0);
assertThat(((CouchbaseCache) cache).getNativeCache())
.isEqualTo(context.getBean("bucket"));
});
}
@Test
public void couchbaseCacheExplicitWithTtl() {
this.contextLoader.config(CouchbaseCacheConfiguration.class)
.env("spring.cache.type=couchbase", "spring.cache.cacheNames=foo,bar",
"spring.cache.couchbase.expiration=2000").load(context -> {
CouchbaseCacheManager cacheManager = validateCacheManager(context,
CouchbaseCacheManager.class);
assertThat(cacheManager.getCacheNames()).containsOnly("foo", "bar");
Cache cache = cacheManager.getCache("foo");
assertThat(cache).isInstanceOf(CouchbaseCache.class);
assertThat(((CouchbaseCache) cache).getTtl()).isEqualTo(2);
assertThat(((CouchbaseCache) cache).getNativeCache())
.isEqualTo(context.getBean("bucket"));
});
"spring.cache.couchbase.expiration=2000")
.load(context -> {
CouchbaseCacheManager cacheManager = validateCacheManager(context,
CouchbaseCacheManager.class);
assertThat(cacheManager.getCacheNames()).containsOnly("foo", "bar");
Cache cache = cacheManager.getCache("foo");
assertThat(cache).isInstanceOf(CouchbaseCache.class);
assertThat(((CouchbaseCache) cache).getTtl()).isEqualTo(2);
assertThat(((CouchbaseCache) cache).getNativeCache())
.isEqualTo(context.getBean("bucket"));
});
}
@Test
public void redisCacheExplicit() {
this.contextLoader.config(RedisCacheConfiguration.class)
.env("spring.cache.type=redis").load(context -> {
RedisCacheManager cacheManager = validateCacheManager(context,
RedisCacheManager.class);
assertThat(cacheManager.getCacheNames()).isEmpty();
assertThat((Boolean) new DirectFieldAccessor(cacheManager)
.getPropertyValue("usePrefix")).isTrue();
});
RedisCacheManager cacheManager = validateCacheManager(context,
RedisCacheManager.class);
assertThat(cacheManager.getCacheNames()).isEmpty();
assertThat((Boolean) new DirectFieldAccessor(cacheManager)
.getPropertyValue("usePrefix")).isTrue();
});
}
@Test
@ -294,97 +298,104 @@ public class CacheAutoConfigurationTests {
public void redisCacheExplicitWithCaches() {
this.contextLoader.config(RedisCacheConfiguration.class)
.env("spring.cache.type=redis", "spring.cache.cacheNames[0]=foo",
"spring.cache.cacheNames[1]=bar").load(context -> {
RedisCacheManager cacheManager = validateCacheManager(context,
RedisCacheManager.class);
assertThat(cacheManager.getCacheNames()).containsOnly("foo", "bar");
});
"spring.cache.cacheNames[1]=bar")
.load(context -> {
RedisCacheManager cacheManager = validateCacheManager(context,
RedisCacheManager.class);
assertThat(cacheManager.getCacheNames()).containsOnly("foo", "bar");
});
}
@Test
public void noOpCacheExplicit() {
this.contextLoader.config(DefaultCacheConfiguration.class)
.env("spring.cache.type=none").load(context -> {
NoOpCacheManager cacheManager = validateCacheManager(context,
NoOpCacheManager.class);
assertThat(cacheManager.getCacheNames()).isEmpty();
});
NoOpCacheManager cacheManager = validateCacheManager(context,
NoOpCacheManager.class);
assertThat(cacheManager.getCacheNames()).isEmpty();
});
}
@Test
public void jCacheCacheNoProviderExplicit() {
this.contextLoader.config(DefaultCacheConfiguration.class)
.env("spring.cache.type=jcache").loadAndFail(ex -> {
assertThat(ex).isInstanceOf(BeanCreationException.class);
assertThat(ex.getMessage()).contains(
"No cache manager could be auto-configured", "JCACHE");
});
assertThat(ex).isInstanceOf(BeanCreationException.class);
assertThat(ex.getMessage()).contains(
"No cache manager could be auto-configured", "JCACHE");
});
}
@Test
public void jCacheCacheWithProvider() {
String cachingProviderFqn = MockCachingProvider.class.getName();
this.contextLoader.config(DefaultCacheConfiguration.class)
.env("spring.cache.type=jcache", "spring.cache.jcache.provider="
+ cachingProviderFqn).load(context -> {
JCacheCacheManager cacheManager = validateCacheManager(context,
JCacheCacheManager.class);
assertThat(cacheManager.getCacheNames()).isEmpty();
assertThat(context.getBean(javax.cache.CacheManager.class))
.isEqualTo(cacheManager.getCacheManager());
});
.env("spring.cache.type=jcache",
"spring.cache.jcache.provider=" + cachingProviderFqn)
.load(context -> {
JCacheCacheManager cacheManager = validateCacheManager(context,
JCacheCacheManager.class);
assertThat(cacheManager.getCacheNames()).isEmpty();
assertThat(context.getBean(javax.cache.CacheManager.class))
.isEqualTo(cacheManager.getCacheManager());
});
}
@Test
public void jCacheCacheWithCaches() {
String cachingProviderFqn = MockCachingProvider.class.getName();
this.contextLoader.config(DefaultCacheConfiguration.class)
.env("spring.cache.type=jcache", "spring.cache.jcache.provider=" + cachingProviderFqn,
.env("spring.cache.type=jcache",
"spring.cache.jcache.provider=" + cachingProviderFqn,
"spring.cache.cacheNames[0]=foo",
"spring.cache.cacheNames[1]=bar").load(context -> {
JCacheCacheManager cacheManager = validateCacheManager(context,
JCacheCacheManager.class);
assertThat(cacheManager.getCacheNames()).containsOnly("foo", "bar");
});
"spring.cache.cacheNames[1]=bar")
.load(context -> {
JCacheCacheManager cacheManager = validateCacheManager(context,
JCacheCacheManager.class);
assertThat(cacheManager.getCacheNames()).containsOnly("foo", "bar");
});
}
@Test
public void jCacheCacheWithCachesAndCustomConfig() {
String cachingProviderFqn = MockCachingProvider.class.getName();
this.contextLoader.config(JCacheCustomConfiguration.class)
.env("spring.cache.type=jcache", "spring.cache.jcache.provider=" + cachingProviderFqn,
.env("spring.cache.type=jcache",
"spring.cache.jcache.provider=" + cachingProviderFqn,
"spring.cache.cacheNames[0]=one",
"spring.cache.cacheNames[1]=two").load(context -> {
JCacheCacheManager cacheManager = validateCacheManager(context,
JCacheCacheManager.class);
assertThat(cacheManager.getCacheNames()).containsOnly("one", "two");
CompleteConfiguration<?, ?> defaultCacheConfiguration = context
.getBean(CompleteConfiguration.class);
verify(cacheManager.getCacheManager()).createCache("one",
defaultCacheConfiguration);
verify(cacheManager.getCacheManager()).createCache("two",
defaultCacheConfiguration);
});
"spring.cache.cacheNames[1]=two")
.load(context -> {
JCacheCacheManager cacheManager = validateCacheManager(context,
JCacheCacheManager.class);
assertThat(cacheManager.getCacheNames()).containsOnly("one", "two");
CompleteConfiguration<?, ?> defaultCacheConfiguration = context
.getBean(CompleteConfiguration.class);
verify(cacheManager.getCacheManager()).createCache("one",
defaultCacheConfiguration);
verify(cacheManager.getCacheManager()).createCache("two",
defaultCacheConfiguration);
});
}
@Test
public void jCacheCacheWithExistingJCacheManager() {
this.contextLoader.config(JCacheCustomCacheManager.class)
.env("spring.cache.type=jcache").load(context -> {
JCacheCacheManager cacheManager = validateCacheManager(context,
JCacheCacheManager.class);
assertThat(cacheManager.getCacheManager())
.isEqualTo(context.getBean("customJCacheCacheManager"));
});
JCacheCacheManager cacheManager = validateCacheManager(context,
JCacheCacheManager.class);
assertThat(cacheManager.getCacheManager())
.isEqualTo(context.getBean("customJCacheCacheManager"));
});
}
@Test
public void jCacheCacheWithUnknownProvider() {
String wrongCachingProviderFqn = "org.acme.FooBar";
this.contextLoader.config(DefaultCacheConfiguration.class)
.env("spring.cache.type=jcache", "spring.cache.jcache.provider="
+ wrongCachingProviderFqn).loadAndFail(BeanCreationException.class,
ex -> assertThat(ex.getMessage().contains(wrongCachingProviderFqn)));
.env("spring.cache.type=jcache",
"spring.cache.jcache.provider=" + wrongCachingProviderFqn)
.loadAndFail(BeanCreationException.class, ex -> assertThat(
ex.getMessage().contains(wrongCachingProviderFqn)));
}
@Test
@ -392,14 +403,16 @@ public class CacheAutoConfigurationTests {
String cachingProviderFqn = MockCachingProvider.class.getName();
String configLocation = "org/springframework/boot/autoconfigure/hazelcast/hazelcast-specific.xml";
this.contextLoader.config(JCacheCustomConfiguration.class)
.env("spring.cache.type=jcache", "spring.cache.jcache.provider=" + cachingProviderFqn,
"spring.cache.jcache.config=" + configLocation).load(context -> {
JCacheCacheManager cacheManager = validateCacheManager(context,
JCacheCacheManager.class);
Resource configResource = new ClassPathResource(configLocation);
assertThat(cacheManager.getCacheManager().getURI())
.isEqualTo(configResource.getURI());
});
.env("spring.cache.type=jcache",
"spring.cache.jcache.provider=" + cachingProviderFqn,
"spring.cache.jcache.config=" + configLocation)
.load(context -> {
JCacheCacheManager cacheManager = validateCacheManager(context,
JCacheCacheManager.class);
Resource configResource = new ClassPathResource(configLocation);
assertThat(cacheManager.getCacheManager().getURI())
.isEqualTo(configResource.getURI());
});
}
@Test
@ -410,21 +423,22 @@ public class CacheAutoConfigurationTests {
.env("spring.cache.type=jcache",
"spring.cache.jcache.provider=" + cachingProviderFqn,
"spring.cache.jcache.config=" + configLocation)
.loadAndFail(BeanCreationException.class, ex ->
assertThat(ex.getMessage()).contains("does not exist", configLocation));
.loadAndFail(BeanCreationException.class,
ex -> assertThat(ex.getMessage()).contains("does not exist",
configLocation));
}
@Test
public void ehcacheCacheWithCaches() {
this.contextLoader.config(DefaultCacheConfiguration.class)
.env("spring.cache.type=ehcache").load(context -> {
EhCacheCacheManager cacheManager = validateCacheManager(context,
EhCacheCacheManager.class);
assertThat(cacheManager.getCacheNames()).containsOnly(
"cacheTest1", "cacheTest2");
assertThat(context.getBean(net.sf.ehcache.CacheManager.class))
.isEqualTo(cacheManager.getCacheManager());
});
EhCacheCacheManager cacheManager = validateCacheManager(context,
EhCacheCacheManager.class);
assertThat(cacheManager.getCacheNames()).containsOnly("cacheTest1",
"cacheTest2");
assertThat(context.getBean(net.sf.ehcache.CacheManager.class))
.isEqualTo(cacheManager.getCacheManager());
});
}
@Test
@ -441,8 +455,8 @@ public class CacheAutoConfigurationTests {
.load(context -> {
EhCacheCacheManager cacheManager = validateCacheManager(context,
EhCacheCacheManager.class);
assertThat(cacheManager.getCacheNames()).containsOnly("cacheOverrideTest1",
"cacheOverrideTest2");
assertThat(cacheManager.getCacheNames())
.containsOnly("cacheOverrideTest1", "cacheOverrideTest2");
});
}
@ -450,11 +464,11 @@ public class CacheAutoConfigurationTests {
public void ehcacheCacheWithExistingCacheManager() {
this.contextLoader.config(EhCacheCustomCacheManager.class)
.env("spring.cache.type=ehcache").load(context -> {
EhCacheCacheManager cacheManager = validateCacheManager(context,
EhCacheCacheManager.class);
assertThat(cacheManager.getCacheManager())
.isEqualTo(context.getBean("customEhCacheCacheManager"));
});
EhCacheCacheManager cacheManager = validateCacheManager(context,
EhCacheCacheManager.class);
assertThat(cacheManager.getCacheManager())
.isEqualTo(context.getBean("customEhCacheCacheManager"));
});
}
@Test
@ -464,11 +478,12 @@ public class CacheAutoConfigurationTests {
.env("spring.cache.type=jcache",
"spring.cache.jcache.provider=" + cachingProviderFqn,
"spring.cache.cacheNames[0]=foo",
"spring.cache.cacheNames[1]=bar").load(context -> {
JCacheCacheManager cacheManager = validateCacheManager(context,
JCacheCacheManager.class);
assertThat(cacheManager.getCacheNames()).containsOnly("foo", "bar");
});
"spring.cache.cacheNames[1]=bar")
.load(context -> {
JCacheCacheManager cacheManager = validateCacheManager(context,
JCacheCacheManager.class);
assertThat(cacheManager.getCacheNames()).containsOnly("foo", "bar");
});
}
@Test
@ -478,15 +493,16 @@ public class CacheAutoConfigurationTests {
this.contextLoader.config(DefaultCacheConfiguration.class)
.env("spring.cache.type=jcache",
"spring.cache.jcache.provider=" + cachingProviderFqn,
"spring.cache.jcache.config=" + configLocation).load(context -> {
JCacheCacheManager cacheManager = validateCacheManager(context,
JCacheCacheManager.class);
"spring.cache.jcache.config=" + configLocation)
.load(context -> {
JCacheCacheManager cacheManager = validateCacheManager(context,
JCacheCacheManager.class);
Resource configResource = new ClassPathResource(configLocation);
assertThat(cacheManager.getCacheManager().getURI())
.isEqualTo(configResource.getURI());
assertThat(cacheManager.getCacheNames()).containsOnly("foo", "bar");
});
Resource configResource = new ClassPathResource(configLocation);
assertThat(cacheManager.getCacheManager().getURI())
.isEqualTo(configResource.getURI());
assertThat(cacheManager.getCacheNames()).containsOnly("foo", "bar");
});
}
@Test
@ -494,14 +510,15 @@ public class CacheAutoConfigurationTests {
this.contextLoader.autoConfigFirst(HazelcastAutoConfiguration.class)
.config(DefaultCacheConfiguration.class)
.env("spring.cache.type=hazelcast").load(context -> {
HazelcastCacheManager cacheManager = validateCacheManager(context,
HazelcastCacheManager.class);
// NOTE: the hazelcast implementation knows about a cache in a lazy manner.
cacheManager.getCache("defaultCache");
assertThat(cacheManager.getCacheNames()).containsOnly("defaultCache");
assertThat(context.getBean(HazelcastInstance.class))
.isEqualTo(cacheManager.getHazelcastInstance());
});
HazelcastCacheManager cacheManager = validateCacheManager(context,
HazelcastCacheManager.class);
// NOTE: the hazelcast implementation knows about a cache in a lazy
// manner.
cacheManager.getCache("defaultCache");
assertThat(cacheManager.getCacheNames()).containsOnly("defaultCache");
assertThat(context.getBean(HazelcastInstance.class))
.isEqualTo(cacheManager.getHazelcastInstance());
});
}
@Test
@ -514,28 +531,32 @@ public class CacheAutoConfigurationTests {
public void hazelcastCacheWithExistingHazelcastInstance() {
this.contextLoader.config(HazelcastCustomHazelcastInstance.class)
.env("spring.cache.type=hazelcast").load(context -> {
HazelcastCacheManager cacheManager = validateCacheManager(context,
HazelcastCacheManager.class);
assertThat(cacheManager.getHazelcastInstance())
.isEqualTo(context.getBean("customHazelcastInstance"));
});
HazelcastCacheManager cacheManager = validateCacheManager(context,
HazelcastCacheManager.class);
assertThat(cacheManager.getHazelcastInstance())
.isEqualTo(context.getBean("customHazelcastInstance"));
});
}
@Test
public void hazelcastCacheWithHazelcastAutoConfiguration() throws IOException {
String hazelcastConfig = "org/springframework/boot/autoconfigure/hazelcast/hazelcast-specific.xml";
this.contextLoader.autoConfigFirst(HazelcastAutoConfiguration.class)
.config(DefaultCacheConfiguration.class).env("spring.cache.type=hazelcast",
"spring.hazelcast.config=" + hazelcastConfig).load(context -> {
HazelcastCacheManager cacheManager = validateCacheManager(context,
HazelcastCacheManager.class);
HazelcastInstance hazelcastInstance = context.getBean(HazelcastInstance.class);
assertThat(cacheManager.getHazelcastInstance()).isSameAs(hazelcastInstance);
assertThat(hazelcastInstance.getConfig().getConfigurationFile())
.isEqualTo(new ClassPathResource(hazelcastConfig).getFile());
assertThat(cacheManager.getCache("foobar")).isNotNull();
assertThat(cacheManager.getCacheNames()).containsOnly("foobar");
});
.config(DefaultCacheConfiguration.class)
.env("spring.cache.type=hazelcast",
"spring.hazelcast.config=" + hazelcastConfig)
.load(context -> {
HazelcastCacheManager cacheManager = validateCacheManager(context,
HazelcastCacheManager.class);
HazelcastInstance hazelcastInstance = context
.getBean(HazelcastInstance.class);
assertThat(cacheManager.getHazelcastInstance())
.isSameAs(hazelcastInstance);
assertThat(hazelcastInstance.getConfig().getConfigurationFile())
.isEqualTo(new ClassPathResource(hazelcastConfig).getFile());
assertThat(cacheManager.getCache("foobar")).isNotNull();
assertThat(cacheManager.getCacheNames()).containsOnly("foobar");
});
}
@Test
@ -546,12 +567,14 @@ public class CacheAutoConfigurationTests {
.env("spring.cache.type=jcache",
"spring.cache.jcache.provider=" + cachingProviderFqn,
"spring.cache.cacheNames[0]=foo",
"spring.cache.cacheNames[1]=bar").load(context -> {
JCacheCacheManager cacheManager = validateCacheManager(context,
JCacheCacheManager.class);
assertThat(cacheManager.getCacheNames()).containsOnly("foo", "bar");
assertThat(Hazelcast.getAllHazelcastInstances()).hasSize(1);
});
"spring.cache.cacheNames[1]=bar")
.load(context -> {
JCacheCacheManager cacheManager = validateCacheManager(context,
JCacheCacheManager.class);
assertThat(cacheManager.getCacheNames()).containsOnly("foo",
"bar");
assertThat(Hazelcast.getAllHazelcastInstances()).hasSize(1);
});
}
finally {
Caching.getCachingProvider(cachingProviderFqn).close();
@ -566,15 +589,16 @@ public class CacheAutoConfigurationTests {
this.contextLoader.config(DefaultCacheConfiguration.class)
.env("spring.cache.type=jcache",
"spring.cache.jcache.provider=" + cachingProviderFqn,
"spring.cache.jcache.config=" + configLocation).load(context -> {
JCacheCacheManager cacheManager = validateCacheManager(context,
JCacheCacheManager.class);
"spring.cache.jcache.config=" + configLocation)
.load(context -> {
JCacheCacheManager cacheManager = validateCacheManager(context,
JCacheCacheManager.class);
Resource configResource = new ClassPathResource(configLocation);
assertThat(cacheManager.getCacheManager().getURI())
.isEqualTo(configResource.getURI());
assertThat(Hazelcast.getAllHazelcastInstances()).hasSize(1);
});
Resource configResource = new ClassPathResource(configLocation);
assertThat(cacheManager.getCacheManager().getURI())
.isEqualTo(configResource.getURI());
assertThat(Hazelcast.getAllHazelcastInstances()).hasSize(1);
});
}
finally {
Caching.getCachingProvider(cachingProviderFqn).close();
@ -585,31 +609,37 @@ public class CacheAutoConfigurationTests {
public void hazelcastAsJCacheWithExistingHazelcastInstance() throws IOException {
String cachingProviderFqn = HazelcastCachingProvider.class.getName();
this.contextLoader.autoConfig(HazelcastAutoConfiguration.class)
.config(DefaultCacheConfiguration.class).env("spring.cache.type=jcache",
"spring.cache.jcache.provider=" + cachingProviderFqn).load(context -> {
JCacheCacheManager cacheManager = validateCacheManager(context,
JCacheCacheManager.class);
javax.cache.CacheManager jCacheManager = cacheManager.getCacheManager();
assertThat(jCacheManager)
.isInstanceOf(com.hazelcast.cache.HazelcastCacheManager.class);
assertThat(context.getBeansOfType(HazelcastInstance.class)).hasSize(1);
HazelcastInstance hazelcastInstance = context.getBean(HazelcastInstance.class);
assertThat(((com.hazelcast.cache.HazelcastCacheManager) jCacheManager)
.getHazelcastInstance()).isSameAs(hazelcastInstance);
assertThat(hazelcastInstance.getName()).isEqualTo("default-instance");
assertThat(Hazelcast.getAllHazelcastInstances()).hasSize(1);
});
.config(DefaultCacheConfiguration.class)
.env("spring.cache.type=jcache",
"spring.cache.jcache.provider=" + cachingProviderFqn)
.load(context -> {
JCacheCacheManager cacheManager = validateCacheManager(context,
JCacheCacheManager.class);
javax.cache.CacheManager jCacheManager = cacheManager
.getCacheManager();
assertThat(jCacheManager).isInstanceOf(
com.hazelcast.cache.HazelcastCacheManager.class);
assertThat(context.getBeansOfType(HazelcastInstance.class))
.hasSize(1);
HazelcastInstance hazelcastInstance = context
.getBean(HazelcastInstance.class);
assertThat(((com.hazelcast.cache.HazelcastCacheManager) jCacheManager)
.getHazelcastInstance()).isSameAs(hazelcastInstance);
assertThat(hazelcastInstance.getName()).isEqualTo("default-instance");
assertThat(Hazelcast.getAllHazelcastInstances()).hasSize(1);
});
}
@Test
public void infinispanCacheWithConfig() {
this.contextLoader.config(DefaultCacheConfiguration.class)
.env("spring.cache.type=infinispan",
"spring.cache.infinispan.config=infinispan.xml").load(context -> {
SpringEmbeddedCacheManager cacheManager = validateCacheManager(context,
SpringEmbeddedCacheManager.class);
assertThat(cacheManager.getCacheNames()).contains("foo", "bar");
});
"spring.cache.infinispan.config=infinispan.xml")
.load(context -> {
SpringEmbeddedCacheManager cacheManager = validateCacheManager(
context, SpringEmbeddedCacheManager.class);
assertThat(cacheManager.getCacheNames()).contains("foo", "bar");
});
}
@Test
@ -622,25 +652,27 @@ public class CacheAutoConfigurationTests {
public void infinispanCacheWithCaches() {
this.contextLoader.config(DefaultCacheConfiguration.class)
.env("spring.cache.type=infinispan", "spring.cache.cacheNames[0]=foo",
"spring.cache.cacheNames[1]=bar").load(context -> {
SpringEmbeddedCacheManager cacheManager = validateCacheManager(context,
SpringEmbeddedCacheManager.class);
assertThat(cacheManager.getCacheNames()).containsOnly("foo", "bar");
});
"spring.cache.cacheNames[1]=bar")
.load(context -> {
SpringEmbeddedCacheManager cacheManager = validateCacheManager(
context, SpringEmbeddedCacheManager.class);
assertThat(cacheManager.getCacheNames()).containsOnly("foo", "bar");
});
}
@Test
public void infinispanCacheWithCachesAndCustomConfig() {
this.contextLoader.config(InfinispanCustomConfiguration.class)
.env("spring.cache.type=infinispan", "spring.cache.cacheNames[0]=foo",
"spring.cache.cacheNames[1]=bar").load(context -> {
SpringEmbeddedCacheManager cacheManager = validateCacheManager(context,
SpringEmbeddedCacheManager.class);
assertThat(cacheManager.getCacheNames()).containsOnly("foo", "bar");
ConfigurationBuilder defaultConfigurationBuilder = context
.getBean(ConfigurationBuilder.class);
verify(defaultConfigurationBuilder, times(2)).build();
});
"spring.cache.cacheNames[1]=bar")
.load(context -> {
SpringEmbeddedCacheManager cacheManager = validateCacheManager(
context, SpringEmbeddedCacheManager.class);
assertThat(cacheManager.getCacheNames()).containsOnly("foo", "bar");
ConfigurationBuilder defaultConfigurationBuilder = context
.getBean(ConfigurationBuilder.class);
verify(defaultConfigurationBuilder, times(2)).build();
});
}
@Test
@ -650,11 +682,12 @@ public class CacheAutoConfigurationTests {
.env("spring.cache.type=jcache",
"spring.cache.jcache.provider=" + cachingProviderFqn,
"spring.cache.cacheNames[0]=foo",
"spring.cache.cacheNames[1]=bar").load(context -> {
JCacheCacheManager cacheManager = validateCacheManager(context,
JCacheCacheManager.class);
assertThat(cacheManager.getCacheNames()).containsOnly("foo", "bar");
});
"spring.cache.cacheNames[1]=bar")
.load(context -> {
JCacheCacheManager cacheManager = validateCacheManager(context,
JCacheCacheManager.class);
assertThat(cacheManager.getCacheNames()).containsOnly("foo", "bar");
});
}
@Test
@ -664,30 +697,33 @@ public class CacheAutoConfigurationTests {
this.contextLoader.config(DefaultCacheConfiguration.class)
.env("spring.cache.type=jcache",
"spring.cache.jcache.provider=" + cachingProviderFqn,
"spring.cache.jcache.config=" + configLocation).load(context -> {
JCacheCacheManager cacheManager = validateCacheManager(context,
JCacheCacheManager.class);
"spring.cache.jcache.config=" + configLocation)
.load(context -> {
JCacheCacheManager cacheManager = validateCacheManager(context,
JCacheCacheManager.class);
Resource configResource = new ClassPathResource(configLocation);
assertThat(cacheManager.getCacheManager().getURI())
.isEqualTo(configResource.getURI());
});
Resource configResource = new ClassPathResource(configLocation);
assertThat(cacheManager.getCacheManager().getURI())
.isEqualTo(configResource.getURI());
});
}
@Test
public void jCacheCacheWithCachesAndCustomizer() {
String cachingProviderFqn = HazelcastCachingProvider.class.getName();
try {
this.contextLoader.config(JCacheWithCustomizerConfiguration.class).env(
"spring.cache.type=jcache",
"spring.cache.jcache.provider=" + cachingProviderFqn,
"spring.cache.cacheNames[0]=foo",
"spring.cache.cacheNames[1]=bar").load(context -> {
JCacheCacheManager cacheManager = validateCacheManager(context,
JCacheCacheManager.class);
// see customizer
assertThat(cacheManager.getCacheNames()).containsOnly("foo", "custom1");
});
this.contextLoader.config(JCacheWithCustomizerConfiguration.class)
.env("spring.cache.type=jcache",
"spring.cache.jcache.provider=" + cachingProviderFqn,
"spring.cache.cacheNames[0]=foo",
"spring.cache.cacheNames[1]=bar")
.load(context -> {
JCacheCacheManager cacheManager = validateCacheManager(context,
JCacheCacheManager.class);
// see customizer
assertThat(cacheManager.getCacheNames()).containsOnly("foo",
"custom1");
});
}
finally {
Caching.getCachingProvider(cachingProviderFqn).close();
@ -697,17 +733,17 @@ public class CacheAutoConfigurationTests {
@Test
public void caffeineCacheWithExplicitCaches() {
this.contextLoader.config(DefaultCacheConfiguration.class)
.env("spring.cache.type=caffeine",
"spring.cache.cacheNames=foo").load(context -> {
CaffeineCacheManager cacheManager = validateCacheManager(context,
CaffeineCacheManager.class);
assertThat(cacheManager.getCacheNames()).containsOnly("foo");
Cache foo = cacheManager.getCache("foo");
foo.get("1");
// See next tests: no spec given so stats should be disabled
assertThat(((CaffeineCache) foo).getNativeCache().stats().missCount())
.isEqualTo(0L);
});
.env("spring.cache.type=caffeine", "spring.cache.cacheNames=foo")
.load(context -> {
CaffeineCacheManager cacheManager = validateCacheManager(context,
CaffeineCacheManager.class);
assertThat(cacheManager.getCacheNames()).containsOnly("foo");
Cache foo = cacheManager.getCache("foo");
foo.get("1");
// See next tests: no spec given so stats should be disabled
assertThat(((CaffeineCache) foo).getNativeCache().stats().missCount())
.isEqualTo(0L);
});
}
@Test
@ -718,26 +754,24 @@ public class CacheAutoConfigurationTests {
@Test
public void caffeineCacheWithExplicitCacheBuilder() {
this.contextLoader.config(CaffeineCacheBuilderConfiguration.class).env(
"spring.cache.type=caffeine", "spring.cache.cacheNames=foo,bar")
this.contextLoader.config(CaffeineCacheBuilderConfiguration.class)
.env("spring.cache.type=caffeine", "spring.cache.cacheNames=foo,bar")
.load(this::validateCaffeineCacheWithStats);
}
@Test
public void caffeineCacheExplicitWithSpec() {
this.contextLoader.config(CaffeineCacheSpecConfiguration.class).env(
"spring.cache.type=caffeine", "spring.cache.cacheNames[0]=foo",
"spring.cache.cacheNames[1]=bar")
this.contextLoader.config(CaffeineCacheSpecConfiguration.class)
.env("spring.cache.type=caffeine", "spring.cache.cacheNames[0]=foo",
"spring.cache.cacheNames[1]=bar")
.load(this::validateCaffeineCacheWithStats);
}
@Test
public void caffeineCacheExplicitWithSpecString() {
this.contextLoader.config(DefaultCacheConfiguration.class)
.env("spring.cache.type=caffeine",
"spring.cache.caffeine.spec=recordStats",
"spring.cache.cacheNames[0]=foo",
"spring.cache.cacheNames[1]=bar")
this.contextLoader.config(DefaultCacheConfiguration.class).env(
"spring.cache.type=caffeine", "spring.cache.caffeine.spec=recordStats",
"spring.cache.cacheNames[0]=foo", "spring.cache.cacheNames[1]=bar")
.load(this::validateCaffeineCacheWithStats);
}
@ -761,24 +795,27 @@ public class CacheAutoConfigurationTests {
@SuppressWarnings("rawtypes")
private void testCustomizers(Class<?> config, String cacheType,
String... expectedCustomizerNames) {
this.contextLoader.config(config)
.env("spring.cache.type=" + cacheType).load(context -> {
CacheManager cacheManager = validateCacheManager(context, CacheManager.class);
List<String> expected = new ArrayList<>();
expected.addAll(Arrays.asList(expectedCustomizerNames));
Map<String, CacheManagerTestCustomizer> map = context
.getBeansOfType(CacheManagerTestCustomizer.class);
for (Map.Entry<String, CacheManagerTestCustomizer> entry : map.entrySet()) {
if (expected.contains(entry.getKey())) {
expected.remove(entry.getKey());
assertThat(entry.getValue().cacheManager).isSameAs(cacheManager);
}
else {
assertThat(entry.getValue().cacheManager).isNull();
}
}
assertThat(expected).hasSize(0);
});
this.contextLoader.config(config).env("spring.cache.type=" + cacheType)
.load(context -> {
CacheManager cacheManager = validateCacheManager(context,
CacheManager.class);
List<String> expected = new ArrayList<>();
expected.addAll(Arrays.asList(expectedCustomizerNames));
Map<String, CacheManagerTestCustomizer> map = context
.getBeansOfType(CacheManagerTestCustomizer.class);
for (Map.Entry<String, CacheManagerTestCustomizer> entry : map
.entrySet()) {
if (expected.contains(entry.getKey())) {
expected.remove(entry.getKey());
assertThat(entry.getValue().cacheManager)
.isSameAs(cacheManager);
}
else {
assertThat(entry.getValue().cacheManager).isNull();
}
}
assertThat(expected).hasSize(0);
});
}
@Configuration

58
spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/hazelcast/HazelcastAutoConfigurationClientTests.java
View File

@ -29,6 +29,7 @@ import org.junit.Test;
import org.springframework.beans.factory.BeanCreationException;
import org.springframework.boot.test.context.ContextLoader;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@ -59,29 +60,36 @@ public class HazelcastAutoConfigurationClientTests {
}
}
private final ContextLoader contextLoader = new ContextLoader()
.autoConfig(HazelcastAutoConfiguration.class);
private final ContextLoader<AnnotationConfigApplicationContext> contextLoader = ContextLoader
.standard().autoConfig(HazelcastAutoConfiguration.class);
@Test
public void systemProperty() throws IOException {
this.contextLoader.systemProperty(HazelcastClientConfiguration.CONFIG_SYSTEM_PROPERTY,
"classpath:org/springframework/boot/autoconfigure/hazelcast/"
+ "hazelcast-client-specific.xml").load(context -> {
HazelcastInstance hazelcastInstance = context
.getBean(HazelcastInstance.class);
assertThat(hazelcastInstance).isInstanceOf(HazelcastClientProxy.class);
assertThat(hazelcastInstance.getName()).startsWith("hz.client_");
});
this.contextLoader
.systemProperty(HazelcastClientConfiguration.CONFIG_SYSTEM_PROPERTY,
"classpath:org/springframework/boot/autoconfigure/hazelcast/"
+ "hazelcast-client-specific.xml")
.load(context -> {
HazelcastInstance hazelcastInstance = context
.getBean(HazelcastInstance.class);
assertThat(hazelcastInstance)
.isInstanceOf(HazelcastClientProxy.class);
assertThat(hazelcastInstance.getName()).startsWith("hz.client_");
});
}
@Test
public void explicitConfigFile() throws IOException {
this.contextLoader.env("spring.hazelcast.config=org/springframework/boot/autoconfigure/"
+ "hazelcast/hazelcast-client-specific.xml").load(context -> {
HazelcastInstance hazelcastInstance = context.getBean(HazelcastInstance.class);
assertThat(hazelcastInstance).isInstanceOf(HazelcastClientProxy.class);
assertThat(hazelcastInstance.getName()).startsWith("hz.client_");
});
this.contextLoader
.env("spring.hazelcast.config=org/springframework/boot/autoconfigure/"
+ "hazelcast/hazelcast-client-specific.xml")
.load(context -> {
HazelcastInstance hazelcastInstance = context
.getBean(HazelcastInstance.class);
assertThat(hazelcastInstance)
.isInstanceOf(HazelcastClientProxy.class);
assertThat(hazelcastInstance.getName()).startsWith("hz.client_");
});
}
@Test
@ -90,26 +98,28 @@ public class HazelcastAutoConfigurationClientTests {
.load(context -> {
HazelcastInstance hazelcastInstance = context
.getBean(HazelcastInstance.class);
assertThat(hazelcastInstance).isInstanceOf(HazelcastClientProxy.class);
assertThat(hazelcastInstance)
.isInstanceOf(HazelcastClientProxy.class);
assertThat(hazelcastInstance.getName()).startsWith("hz.client_");
});
}
@Test
public void unknownConfigFile() {
this.contextLoader.env("spring.hazelcast.config=foo/bar/unknown.xml")
.loadAndFail(BeanCreationException.class, ex ->
assertThat(ex.getMessage()).contains("foo/bar/unknown.xml"));
this.contextLoader.env("spring.hazelcast.config=foo/bar/unknown.xml").loadAndFail(
BeanCreationException.class,
ex -> assertThat(ex.getMessage()).contains("foo/bar/unknown.xml"));
}
@Test
public void clientConfigTakesPrecedence() {
this.contextLoader.config(HazelcastServerAndClientConfig.class)
.env("spring.hazelcast.config=this-is-ignored.xml").load(context -> {
HazelcastInstance hazelcastInstance = context
.getBean(HazelcastInstance.class);
assertThat(hazelcastInstance).isInstanceOf(HazelcastClientProxy.class);
});
HazelcastInstance hazelcastInstance = context
.getBean(HazelcastInstance.class);
assertThat(hazelcastInstance)
.isInstanceOf(HazelcastClientProxy.class);
});
}
@Configuration

81
spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/hazelcast/HazelcastAutoConfigurationServerTests.java
View File

@ -30,6 +30,7 @@ import org.springframework.beans.factory.BeanCreationException;
import org.springframework.boot.test.context.ContextLoader;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
@ -45,8 +46,8 @@ import static org.assertj.core.api.Assertions.assertThat;
@ClassPathExclusions("hazelcast-client-*.jar")
public class HazelcastAutoConfigurationServerTests {
private final ContextLoader contextLoader = new ContextLoader()
.autoConfig(HazelcastAutoConfiguration.class);
private final ContextLoader<AnnotationConfigApplicationContext> contextLoader = ContextLoader
.standard().autoConfig(HazelcastAutoConfiguration.class);
@Test
public void defaultConfigFile() throws IOException {
@ -61,8 +62,9 @@ public class HazelcastAutoConfigurationServerTests {
@Test
public void systemProperty() throws IOException {
this.contextLoader.systemProperty(HazelcastServerConfiguration.CONFIG_SYSTEM_PROPERTY,
"classpath:org/springframework/boot/autoconfigure/hazelcast/hazelcast-specific.xml")
this.contextLoader
.systemProperty(HazelcastServerConfiguration.CONFIG_SYSTEM_PROPERTY,
"classpath:org/springframework/boot/autoconfigure/hazelcast/hazelcast-specific.xml")
.load(context -> {
HazelcastInstance hazelcastInstance = context
@ -75,32 +77,36 @@ public class HazelcastAutoConfigurationServerTests {
@Test
public void explicitConfigFile() throws IOException {
this.contextLoader.env("spring.hazelcast.config=org/springframework/boot/autoconfigure/hazelcast/"
+ "hazelcast-specific.xml").load(context -> {
HazelcastInstance hazelcastInstance = context
.getBean(HazelcastInstance.class);
assertThat(hazelcastInstance.getConfig().getConfigurationFile()).isEqualTo(
new ClassPathResource("org/springframework/boot/autoconfigure/hazelcast"
+ "/hazelcast-specific.xml").getFile());
});
this.contextLoader
.env("spring.hazelcast.config=org/springframework/boot/autoconfigure/hazelcast/"
+ "hazelcast-specific.xml")
.load(context -> {
HazelcastInstance hazelcastInstance = context
.getBean(HazelcastInstance.class);
assertThat(hazelcastInstance.getConfig().getConfigurationFile())
.isEqualTo(new ClassPathResource(
"org/springframework/boot/autoconfigure/hazelcast"
+ "/hazelcast-specific.xml").getFile());
});
}
@Test
public void explicitConfigUrl() throws IOException {
this.contextLoader
.env("spring.hazelcast.config=hazelcast-default.xml").load(context -> {
HazelcastInstance hazelcastInstance = context
.getBean(HazelcastInstance.class);
assertThat(hazelcastInstance.getConfig().getConfigurationUrl())
.isEqualTo(new ClassPathResource("hazelcast-default.xml").getURL());
});
this.contextLoader.env("spring.hazelcast.config=hazelcast-default.xml")
.load(context -> {
HazelcastInstance hazelcastInstance = context
.getBean(HazelcastInstance.class);
assertThat(hazelcastInstance.getConfig().getConfigurationUrl())
.isEqualTo(new ClassPathResource("hazelcast-default.xml")
.getURL());
});
}
@Test
public void unknownConfigFile() {
this.contextLoader.env("spring.hazelcast.config=foo/bar/unknown.xml")
.loadAndFail(BeanCreationException.class, ex ->
assertThat(ex.getMessage()).contains("foo/bar/unknown.xml"));
this.contextLoader.env("spring.hazelcast.config=foo/bar/unknown.xml").loadAndFail(
BeanCreationException.class,
ex -> assertThat(ex.getMessage()).contains("foo/bar/unknown.xml"));
}
@Test
@ -109,15 +115,16 @@ public class HazelcastAutoConfigurationServerTests {
HazelcastInstance existingHazelcastInstance = Hazelcast
.newHazelcastInstance(config);
try {
this.contextLoader.config(HazelcastConfigWithName.class).env(
"spring.hazelcast.config=this-is-ignored.xml").load(context -> {
HazelcastInstance hazelcastInstance = context
.getBean(HazelcastInstance.class);
assertThat(hazelcastInstance.getConfig().getInstanceName())
.isEqualTo("my-test-instance");
// Should reuse any existing instance by default.
assertThat(hazelcastInstance).isEqualTo(existingHazelcastInstance);
});
this.contextLoader.config(HazelcastConfigWithName.class)
.env("spring.hazelcast.config=this-is-ignored.xml").load(context -> {
HazelcastInstance hazelcastInstance = context
.getBean(HazelcastInstance.class);
assertThat(hazelcastInstance.getConfig().getInstanceName())
.isEqualTo("my-test-instance");
// Should reuse any existing instance by default.
assertThat(hazelcastInstance)
.isEqualTo(existingHazelcastInstance);
});
}
finally {
existingHazelcastInstance.shutdown();
@ -128,12 +135,12 @@ public class HazelcastAutoConfigurationServerTests {
public void configInstanceWithoutName() {
this.contextLoader.config(HazelcastConfigNoName.class)
.env("spring.hazelcast.config=this-is-ignored.xml").load(context -> {
HazelcastInstance hazelcastInstance = context
.getBean(HazelcastInstance.class);
Map<String, QueueConfig> queueConfigs = hazelcastInstance.getConfig()
.getQueueConfigs();
assertThat(queueConfigs).hasSize(1).containsKey("another-queue");
});
HazelcastInstance hazelcastInstance = context
.getBean(HazelcastInstance.class);
Map<String, QueueConfig> queueConfigs = hazelcastInstance.getConfig()
.getQueueConfigs();
assertThat(queueConfigs).hasSize(1).containsKey("another-queue");
});
}
@Configuration

8
spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/hazelcast/HazelcastAutoConfigurationTests.java
View File

@ -22,6 +22,7 @@ import com.hazelcast.core.HazelcastInstance;
import org.junit.Test;
import org.springframework.boot.test.context.ContextLoader;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.core.io.ClassPathResource;
import static org.assertj.core.api.Assertions.assertThat;
@ -33,14 +34,15 @@ import static org.assertj.core.api.Assertions.assertThat;
*/
public class HazelcastAutoConfigurationTests {
private final ContextLoader contextLoader = new ContextLoader()
.autoConfig(HazelcastAutoConfiguration.class);
private final ContextLoader<AnnotationConfigApplicationContext> contextLoader = ContextLoader
.standard().autoConfig(HazelcastAutoConfiguration.class);
@Test
public void defaultConfigFile() throws IOException {
// no hazelcast-client.xml and hazelcast.xml is present in root classpath
this.contextLoader.load(context -> {
HazelcastInstance hazelcastInstance = context.getBean(HazelcastInstance.class);
HazelcastInstance hazelcastInstance = context
.getBean(HazelcastInstance.class);
assertThat(hazelcastInstance.getConfig().getConfigurationUrl())
.isEqualTo(new ClassPathResource("hazelcast.xml").getURL());
});

107
spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceAutoConfigurationTests.java
View File

@ -41,6 +41,7 @@ import org.springframework.boot.jdbc.DatabaseDriver;
import org.springframework.boot.test.context.ContextConsumer;
import org.springframework.boot.test.context.ContextLoader;
import org.springframework.boot.test.context.HidePackagesClassLoader;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
@ -57,15 +58,16 @@ import static org.mockito.Mockito.mock;
*/
public class DataSourceAutoConfigurationTests {
private final ContextLoader contextLoader = new ContextLoader()
.autoConfig(DataSourceAutoConfiguration.class)
private final ContextLoader<AnnotationConfigApplicationContext> contextLoader = ContextLoader
.standard().autoConfig(DataSourceAutoConfiguration.class)
.env("spring.datasource.initialize=false",
"spring.datasource.url:jdbc:hsqldb:mem:testdb-" + new Random().nextInt());
"spring.datasource.url:jdbc:hsqldb:mem:testdb-"
+ new Random().nextInt());
@Test
public void testDefaultDataSourceExists() throws Exception {
this.contextLoader.load(context ->
assertThat(context.getBean(DataSource.class)).isNotNull());
this.contextLoader.load(
context -> assertThat(context.getBean(DataSource.class)).isNotNull());
}
@Test
@ -93,25 +95,25 @@ public class DataSourceAutoConfigurationTests {
@Test
public void testBadDriverClass() throws Exception {
this.contextLoader.env("spring.datasource.driverClassName:org.none.jdbcDriver")
.loadAndFail(BeanCreationException.class, ex ->
assertThat(ex.getMessage()).contains("org.none.jdbcDriver"));
.loadAndFail(BeanCreationException.class,
ex -> assertThat(ex.getMessage())
.contains("org.none.jdbcDriver"));
}
@Test
public void hikariValidatesConnectionByDefault() throws Exception {
assertDataSource(HikariDataSource.class,
Collections.singletonList("org.apache.tomcat"),
dataSource ->
// Use Connection#isValid()
assertThat(dataSource.getConnectionTestQuery()).isNull()
);
Collections.singletonList("org.apache.tomcat"), dataSource ->
// Use Connection#isValid()
assertThat(dataSource.getConnectionTestQuery()).isNull());
}
@Test
public void tomcatIsFallback() throws Exception {
assertDataSource(org.apache.tomcat.jdbc.pool.DataSource.class,
Collections.singletonList("com.zaxxer.hikari"), dataSource ->
assertThat(dataSource.getUrl()).startsWith("jdbc:hsqldb:mem:testdb"));
Collections.singletonList("com.zaxxer.hikari"),
dataSource -> assertThat(dataSource.getUrl())
.startsWith("jdbc:hsqldb:mem:testdb"));
}
@Test
@ -127,8 +129,9 @@ public class DataSourceAutoConfigurationTests {
@Test
public void commonsDbcp2IsFallback() throws Exception {
assertDataSource(BasicDataSource.class,
Arrays.asList("com.zaxxer.hikari", "org.apache.tomcat"), dataSource ->
assertThat(dataSource.getUrl()).startsWith("jdbc:hsqldb:mem:testdb"));
Arrays.asList("com.zaxxer.hikari", "org.apache.tomcat"),
dataSource -> assertThat(dataSource.getUrl())
.startsWith("jdbc:hsqldb:mem:testdb"));
}
@Test
@ -136,7 +139,8 @@ public class DataSourceAutoConfigurationTests {
assertDataSource(org.apache.commons.dbcp2.BasicDataSource.class,
Arrays.asList("com.zaxxer.hikari", "org.apache.tomcat"), dataSource -> {
assertThat(dataSource.getTestOnBorrow()).isEqualTo(true);
assertThat(dataSource.getValidationQuery()).isNull(); // Use Connection#isValid()
assertThat(dataSource.getValidationQuery()).isNull(); // Use
// Connection#isValid()
});
}
@ -144,13 +148,14 @@ public class DataSourceAutoConfigurationTests {
public void testEmbeddedTypeDefaultsUsername() throws Exception {
this.contextLoader.env("spring.datasource.driverClassName:org.hsqldb.jdbcDriver",
"spring.datasource.url:jdbc:hsqldb:mem:testdb").load(context -> {
DataSource bean = context.getBean(DataSource.class);
assertThat(bean).isNotNull();
@SuppressWarnings("resource")
HikariDataSource pool = (HikariDataSource) bean;
assertThat(pool.getDriverClassName()).isEqualTo("org.hsqldb.jdbcDriver");
assertThat(pool.getUsername()).isEqualTo("sa");
});
DataSource bean = context.getBean(DataSource.class);
assertThat(bean).isNotNull();
@SuppressWarnings("resource")
HikariDataSource pool = (HikariDataSource) bean;
assertThat(pool.getDriverClassName())
.isEqualTo("org.hsqldb.jdbcDriver");
assertThat(pool.getUsername()).isEqualTo("sa");
});
}
/**
@ -159,24 +164,28 @@ public class DataSourceAutoConfigurationTests {
*/
@Test
public void explicitTypeNoSupportedDataSource() {
this.contextLoader.classLoader(
new HidePackagesClassLoader("org.apache.tomcat", "com.zaxxer.hikari",
"org.apache.commons.dbcp", "org.apache.commons.dbcp2"))
this.contextLoader
.classLoader(new HidePackagesClassLoader("org.apache.tomcat",
"com.zaxxer.hikari", "org.apache.commons.dbcp",
"org.apache.commons.dbcp2"))
.env("spring.datasource.driverClassName:org.hsqldb.jdbcDriver",
"spring.datasource.url:jdbc:hsqldb:mem:testdb",
"spring.datasource.type:" + SimpleDriverDataSource.class.getName())
"spring.datasource.type:"
+ SimpleDriverDataSource.class.getName())
.load(testExplicitType());
}
@Test
public void explicitTypeSupportedDataSource() {
this.contextLoader.env("spring.datasource.driverClassName:org.hsqldb.jdbcDriver",
"spring.datasource.url:jdbc:hsqldb:mem:testdb",
"spring.datasource.type:" + SimpleDriverDataSource.class.getName())
this.contextLoader
.env("spring.datasource.driverClassName:org.hsqldb.jdbcDriver",
"spring.datasource.url:jdbc:hsqldb:mem:testdb",
"spring.datasource.type:"
+ SimpleDriverDataSource.class.getName())
.load(testExplicitType());
}
private ContextConsumer testExplicitType() {
private ContextConsumer<AnnotationConfigApplicationContext> testExplicitType() {
return context -> {
assertThat(context.getBeansOfType(DataSource.class)).hasSize(1);
DataSource bean = context.getBean(DataSource.class);
@ -187,14 +196,15 @@ public class DataSourceAutoConfigurationTests {
@Test
public void testExplicitDriverClassClearsUsername() throws Exception {
this.contextLoader.env("spring.datasource.driverClassName:" + DatabaseTestDriver.class.getName(),
this.contextLoader.env(
"spring.datasource.driverClassName:" + DatabaseTestDriver.class.getName(),
"spring.datasource.url:jdbc:foo://localhost").load(context -> {
DataSource dataSource = context.getBean(DataSource.class);
assertThat(dataSource).isNotNull();
assertThat(((HikariDataSource) dataSource).getDriverClassName())
.isEqualTo(DatabaseTestDriver.class.getName());
assertThat(((HikariDataSource) dataSource).getUsername()).isNull();
});
DataSource dataSource = context.getBean(DataSource.class);
assertThat(dataSource).isNotNull();
assertThat(((HikariDataSource) dataSource).getDriverClassName())
.isEqualTo(DatabaseTestDriver.class.getName());
assertThat(((HikariDataSource) dataSource).getUsername()).isNull();
});
}
@Test
@ -208,22 +218,21 @@ public class DataSourceAutoConfigurationTests {
@Test
public void testDataSourceIsInitializedEarly() {
this.contextLoader.config(TestInitializedDataSourceConfiguration.class)
.env("spring.datasource.initialize=true").load(context ->
assertThat(context.getBean(
TestInitializedDataSourceConfiguration.class).called).isTrue());
.env("spring.datasource.initialize=true")
.load(context -> assertThat(context
.getBean(TestInitializedDataSourceConfiguration.class).called)
.isTrue());
}
private <T extends DataSource> void assertDataSource(Class<T> expectedType,
List<String> hiddenPackages, Consumer<T> consumer) {
HidePackagesClassLoader classLoader = new HidePackagesClassLoader(
hiddenPackages.toArray(new String[hiddenPackages.size()]));
this.contextLoader
.classLoader(classLoader)
.load(context -> {
DataSource bean = context.getBean(DataSource.class);
assertThat(bean).isInstanceOf(expectedType);
consumer.accept(expectedType.cast(bean));
});
this.contextLoader.classLoader(classLoader).load(context -> {
DataSource bean = context.getBean(DataSource.class);
assertThat(bean).isInstanceOf(expectedType);
consumer.accept(expectedType.cast(bean));
});
}
@Configuration

369
spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jms/JmsAutoConfigurationTests.java
View File

@ -28,6 +28,7 @@ import org.springframework.beans.DirectFieldAccessor;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.boot.autoconfigure.jms.activemq.ActiveMQAutoConfiguration;
import org.springframework.boot.test.context.ContextLoader;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
@ -61,8 +62,9 @@ public class JmsAutoConfigurationTests {
private static final String ACTIVEMQ_NETWORK_URL = "tcp://localhost:61616";
private final ContextLoader contextLoader = new ContextLoader().autoConfig(
ActiveMQAutoConfiguration.class, JmsAutoConfiguration.class);
private final ContextLoader<AnnotationConfigApplicationContext> contextLoader = ContextLoader
.standard()
.autoConfig(ActiveMQAutoConfiguration.class, JmsAutoConfiguration.class);
@Test
public void testDefaultJmsConfiguration() {
@ -82,9 +84,10 @@ public class JmsAutoConfigurationTests {
@Test
public void testConnectionFactoryBackOff() {
this.contextLoader.config(TestConfiguration2.class).load(context ->
assertThat(context.getBean(ActiveMQConnectionFactory.class)
.getBrokerURL()).isEqualTo("foobar"));
this.contextLoader.config(TestConfiguration2.class)
.load(context -> assertThat(
context.getBean(ActiveMQConnectionFactory.class).getBrokerURL())
.isEqualTo("foobar"));
}
@Test
@ -108,15 +111,16 @@ public class JmsAutoConfigurationTests {
public void testJmsTemplateBackOffEverything() {
this.contextLoader.config(TestConfiguration2.class, TestConfiguration3.class,
TestConfiguration5.class).load(context -> {
JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);
assertThat(jmsTemplate.getPriority()).isEqualTo(999);
assertThat(context.getBean(ActiveMQConnectionFactory.class).getBrokerURL())
.isEqualTo("foobar");
JmsMessagingTemplate messagingTemplate = context
.getBean(JmsMessagingTemplate.class);
assertThat(messagingTemplate.getDefaultDestinationName()).isEqualTo("fooBar");
assertThat(messagingTemplate.getJmsTemplate()).isEqualTo(jmsTemplate);
});
JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);
assertThat(jmsTemplate.getPriority()).isEqualTo(999);
assertThat(context.getBean(ActiveMQConnectionFactory.class)
.getBrokerURL()).isEqualTo("foobar");
JmsMessagingTemplate messagingTemplate = context
.getBean(JmsMessagingTemplate.class);
assertThat(messagingTemplate.getDefaultDestinationName())
.isEqualTo("fooBar");
assertThat(messagingTemplate.getJmsTemplate()).isEqualTo(jmsTemplate);
});
}
@Test
@ -131,13 +135,14 @@ public class JmsAutoConfigurationTests {
@Test
public void testJmsListenerContainerFactoryBackOff() {
this.contextLoader.config(TestConfiguration6.class,
EnableJmsConfiguration.class).load(context -> {
JmsListenerContainerFactory<?> jmsListenerContainerFactory = context.getBean(
"jmsListenerContainerFactory", JmsListenerContainerFactory.class);
assertThat(jmsListenerContainerFactory.getClass())
.isEqualTo(SimpleJmsListenerContainerFactory.class);
});
this.contextLoader.config(TestConfiguration6.class, EnableJmsConfiguration.class)
.load(context -> {
JmsListenerContainerFactory<?> jmsListenerContainerFactory = context
.getBean("jmsListenerContainerFactory",
JmsListenerContainerFactory.class);
assertThat(jmsListenerContainerFactory.getClass())
.isEqualTo(SimpleJmsListenerContainerFactory.class);
});
}
@Test
@ -146,52 +151,57 @@ public class JmsAutoConfigurationTests {
.env("spring.jms.listener.autoStartup=false",
"spring.jms.listener.acknowledgeMode=client",
"spring.jms.listener.concurrency=2",
"spring.jms.listener.maxConcurrency=10").load(context -> {
JmsListenerContainerFactory<?> jmsListenerContainerFactory = context.getBean(
"jmsListenerContainerFactory", JmsListenerContainerFactory.class);
assertThat(jmsListenerContainerFactory.getClass())
.isEqualTo(DefaultJmsListenerContainerFactory.class);
DefaultMessageListenerContainer listenerContainer = ((DefaultJmsListenerContainerFactory) jmsListenerContainerFactory)
.createListenerContainer(mock(JmsListenerEndpoint.class));
assertThat(listenerContainer.isAutoStartup()).isFalse();
assertThat(listenerContainer.getSessionAcknowledgeMode())
.isEqualTo(Session.CLIENT_ACKNOWLEDGE);
assertThat(listenerContainer.getConcurrentConsumers()).isEqualTo(2);
assertThat(listenerContainer.getMaxConcurrentConsumers()).isEqualTo(10);
});
"spring.jms.listener.maxConcurrency=10")
.load(context -> {
JmsListenerContainerFactory<?> jmsListenerContainerFactory = context
.getBean("jmsListenerContainerFactory",
JmsListenerContainerFactory.class);
assertThat(jmsListenerContainerFactory.getClass())
.isEqualTo(DefaultJmsListenerContainerFactory.class);
DefaultMessageListenerContainer listenerContainer = ((DefaultJmsListenerContainerFactory) jmsListenerContainerFactory)
.createListenerContainer(mock(JmsListenerEndpoint.class));
assertThat(listenerContainer.isAutoStartup()).isFalse();
assertThat(listenerContainer.getSessionAcknowledgeMode())
.isEqualTo(Session.CLIENT_ACKNOWLEDGE);
assertThat(listenerContainer.getConcurrentConsumers()).isEqualTo(2);
assertThat(listenerContainer.getMaxConcurrentConsumers())
.isEqualTo(10);
});
}
@Test
public void testDefaultContainerFactoryWithJtaTransactionManager() {
this.contextLoader.config(TestConfiguration7.class,
EnableJmsConfiguration.class).load(context -> {
JmsListenerContainerFactory<?> jmsListenerContainerFactory = context.getBean(
"jmsListenerContainerFactory", JmsListenerContainerFactory.class);
assertThat(jmsListenerContainerFactory.getClass())
.isEqualTo(DefaultJmsListenerContainerFactory.class);
DefaultMessageListenerContainer listenerContainer = ((DefaultJmsListenerContainerFactory) jmsListenerContainerFactory)
.createListenerContainer(mock(JmsListenerEndpoint.class));
assertThat(listenerContainer.isSessionTransacted()).isFalse();
assertThat(new DirectFieldAccessor(listenerContainer)
.getPropertyValue("transactionManager"))
.isSameAs(context.getBean(JtaTransactionManager.class));
});
this.contextLoader.config(TestConfiguration7.class, EnableJmsConfiguration.class)
.load(context -> {
JmsListenerContainerFactory<?> jmsListenerContainerFactory = context
.getBean("jmsListenerContainerFactory",
JmsListenerContainerFactory.class);
assertThat(jmsListenerContainerFactory.getClass())
.isEqualTo(DefaultJmsListenerContainerFactory.class);
DefaultMessageListenerContainer listenerContainer = ((DefaultJmsListenerContainerFactory) jmsListenerContainerFactory)
.createListenerContainer(mock(JmsListenerEndpoint.class));
assertThat(listenerContainer.isSessionTransacted()).isFalse();
assertThat(new DirectFieldAccessor(listenerContainer)
.getPropertyValue("transactionManager")).isSameAs(
context.getBean(JtaTransactionManager.class));
});
}
@Test
public void testDefaultContainerFactoryNonJtaTransactionManager() {
this.contextLoader.config(TestConfiguration8.class,
EnableJmsConfiguration.class).load(context -> {
JmsListenerContainerFactory<?> jmsListenerContainerFactory = context.getBean(
"jmsListenerContainerFactory", JmsListenerContainerFactory.class);
assertThat(jmsListenerContainerFactory.getClass())
.isEqualTo(DefaultJmsListenerContainerFactory.class);
DefaultMessageListenerContainer listenerContainer = ((DefaultJmsListenerContainerFactory) jmsListenerContainerFactory)
.createListenerContainer(mock(JmsListenerEndpoint.class));
assertThat(listenerContainer.isSessionTransacted()).isTrue();
assertThat(new DirectFieldAccessor(listenerContainer)
.getPropertyValue("transactionManager")).isNull();
});
this.contextLoader.config(TestConfiguration8.class, EnableJmsConfiguration.class)
.load(context -> {
JmsListenerContainerFactory<?> jmsListenerContainerFactory = context
.getBean("jmsListenerContainerFactory",
JmsListenerContainerFactory.class);
assertThat(jmsListenerContainerFactory.getClass())
.isEqualTo(DefaultJmsListenerContainerFactory.class);
DefaultMessageListenerContainer listenerContainer = ((DefaultJmsListenerContainerFactory) jmsListenerContainerFactory)
.createListenerContainer(mock(JmsListenerEndpoint.class));
assertThat(listenerContainer.isSessionTransacted()).isTrue();
assertThat(new DirectFieldAccessor(listenerContainer)
.getPropertyValue("transactionManager")).isNull();
});
}
@Test
@ -213,32 +223,35 @@ public class JmsAutoConfigurationTests {
public void testDefaultContainerFactoryWithMessageConverters() {
this.contextLoader.config(MessageConvertersConfiguration.class,
EnableJmsConfiguration.class).load(context -> {
JmsListenerContainerFactory<?> jmsListenerContainerFactory = context.getBean(
"jmsListenerContainerFactory", JmsListenerContainerFactory.class);
assertThat(jmsListenerContainerFactory.getClass())
.isEqualTo(DefaultJmsListenerContainerFactory.class);
DefaultMessageListenerContainer listenerContainer = ((DefaultJmsListenerContainerFactory) jmsListenerContainerFactory)
.createListenerContainer(mock(JmsListenerEndpoint.class));
assertThat(listenerContainer.getMessageConverter())
.isSameAs(context.getBean("myMessageConverter"));
});
JmsListenerContainerFactory<?> jmsListenerContainerFactory = context
.getBean("jmsListenerContainerFactory",
JmsListenerContainerFactory.class);
assertThat(jmsListenerContainerFactory.getClass())
.isEqualTo(DefaultJmsListenerContainerFactory.class);
DefaultMessageListenerContainer listenerContainer = ((DefaultJmsListenerContainerFactory) jmsListenerContainerFactory)
.createListenerContainer(mock(JmsListenerEndpoint.class));
assertThat(listenerContainer.getMessageConverter())
.isSameAs(context.getBean("myMessageConverter"));
});
}
@Test
public void testCustomContainerFactoryWithConfigurer() {
this.contextLoader.config(TestConfiguration9.class, EnableJmsConfiguration.class)
.env("spring.jms.listener.autoStartup=false").load(context -> {
assertThat(context.containsBean("jmsListenerContainerFactory")).isTrue();
JmsListenerContainerFactory<?> jmsListenerContainerFactory = context.getBean(
"customListenerContainerFactory", JmsListenerContainerFactory.class);
assertThat(jmsListenerContainerFactory)
.isInstanceOf(DefaultJmsListenerContainerFactory.class);
DefaultMessageListenerContainer listenerContainer = ((DefaultJmsListenerContainerFactory) jmsListenerContainerFactory)
.createListenerContainer(mock(JmsListenerEndpoint.class));
assertThat(listenerContainer.getCacheLevel())
.isEqualTo(DefaultMessageListenerContainer.CACHE_CONSUMER);
assertThat(listenerContainer.isAutoStartup()).isFalse();
});
assertThat(context.containsBean("jmsListenerContainerFactory"))
.isTrue();
JmsListenerContainerFactory<?> jmsListenerContainerFactory = context
.getBean("customListenerContainerFactory",
JmsListenerContainerFactory.class);
assertThat(jmsListenerContainerFactory)
.isInstanceOf(DefaultJmsListenerContainerFactory.class);
DefaultMessageListenerContainer listenerContainer = ((DefaultJmsListenerContainerFactory) jmsListenerContainerFactory)
.createListenerContainer(mock(JmsListenerEndpoint.class));
assertThat(listenerContainer.getCacheLevel())
.isEqualTo(DefaultMessageListenerContainer.CACHE_CONSUMER);
assertThat(listenerContainer.isAutoStartup()).isFalse();
});
}
@Test
@ -252,33 +265,37 @@ public class JmsAutoConfigurationTests {
@Test
public void testJmsTemplateWithDestinationResolver() {
this.contextLoader.config(DestinationResolversConfiguration.class).load(context -> {
JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);
assertThat(jmsTemplate.getDestinationResolver())
.isSameAs(context.getBean("myDestinationResolver"));
});
this.contextLoader.config(DestinationResolversConfiguration.class)
.load(context -> {
JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);
assertThat(jmsTemplate.getDestinationResolver())
.isSameAs(context.getBean("myDestinationResolver"));
});
}
@Test
public void testJmsTemplateFullCustomization() {
this.contextLoader.config(MessageConvertersConfiguration.class).env(
"spring.jms.template.default-destination=testQueue",
"spring.jms.template.delivery-delay=500",
"spring.jms.template.delivery-mode=non-persistent",
"spring.jms.template.priority=6", "spring.jms.template.time-to-live=6000",
"spring.jms.template.receive-timeout=2000").load(context -> {
JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);
assertThat(jmsTemplate.getMessageConverter())
.isSameAs(context.getBean("myMessageConverter"));
assertThat(jmsTemplate.isPubSubDomain()).isFalse();
assertThat(jmsTemplate.getDefaultDestinationName()).isEqualTo("testQueue");
assertThat(jmsTemplate.getDeliveryDelay()).isEqualTo(500);
assertThat(jmsTemplate.getDeliveryMode()).isEqualTo(1);
assertThat(jmsTemplate.getPriority()).isEqualTo(6);
assertThat(jmsTemplate.getTimeToLive()).isEqualTo(6000);
assertThat(jmsTemplate.isExplicitQosEnabled()).isTrue();
assertThat(jmsTemplate.getReceiveTimeout()).isEqualTo(2000);
});
this.contextLoader.config(MessageConvertersConfiguration.class)
.env("spring.jms.template.default-destination=testQueue",
"spring.jms.template.delivery-delay=500",
"spring.jms.template.delivery-mode=non-persistent",
"spring.jms.template.priority=6",
"spring.jms.template.time-to-live=6000",
"spring.jms.template.receive-timeout=2000")
.load(context -> {
JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);
assertThat(jmsTemplate.getMessageConverter())
.isSameAs(context.getBean("myMessageConverter"));
assertThat(jmsTemplate.isPubSubDomain()).isFalse();
assertThat(jmsTemplate.getDefaultDestinationName())
.isEqualTo("testQueue");
assertThat(jmsTemplate.getDeliveryDelay()).isEqualTo(500);
assertThat(jmsTemplate.getDeliveryMode()).isEqualTo(1);
assertThat(jmsTemplate.getPriority()).isEqualTo(6);
assertThat(jmsTemplate.getTimeToLive()).isEqualTo(6000);
assertThat(jmsTemplate.isExplicitQosEnabled()).isTrue();
assertThat(jmsTemplate.getReceiveTimeout()).isEqualTo(2000);
});
}
@Test
@ -301,111 +318,125 @@ public class JmsAutoConfigurationTests {
public void testPubSubDomainActive() {
this.contextLoader.config(TestConfiguration.class)
.env("spring.jms.pubSubDomain:true").load(context -> {
JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);
DefaultMessageListenerContainer defaultMessageListenerContainer = context
.getBean(DefaultJmsListenerContainerFactory.class)
.createListenerContainer(mock(JmsListenerEndpoint.class));
assertThat(jmsTemplate.isPubSubDomain()).isTrue();
assertThat(defaultMessageListenerContainer.isPubSubDomain()).isTrue();
});
JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);
DefaultMessageListenerContainer defaultMessageListenerContainer = context
.getBean(DefaultJmsListenerContainerFactory.class)
.createListenerContainer(mock(JmsListenerEndpoint.class));
assertThat(jmsTemplate.isPubSubDomain()).isTrue();
assertThat(defaultMessageListenerContainer.isPubSubDomain()).isTrue();
});
}
@Test
public void testPubSubDomainOverride() {
this.contextLoader.config(TestConfiguration.class)
.env("spring.jms.pubSubDomain:false").load(context -> {
JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);
ActiveMQConnectionFactory connectionFactory = context
.getBean(ActiveMQConnectionFactory.class);
assertThat(jmsTemplate).isNotNull();
assertThat(jmsTemplate.isPubSubDomain()).isFalse();
assertThat(connectionFactory).isNotNull();
assertThat(connectionFactory).isEqualTo(jmsTemplate.getConnectionFactory());
});
JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);
ActiveMQConnectionFactory connectionFactory = context
.getBean(ActiveMQConnectionFactory.class);
assertThat(jmsTemplate).isNotNull();
assertThat(jmsTemplate.isPubSubDomain()).isFalse();
assertThat(connectionFactory).isNotNull();
assertThat(connectionFactory)
.isEqualTo(jmsTemplate.getConnectionFactory());
});
}
@Test
public void testActiveMQOverriddenStandalone() {
this.contextLoader.config(TestConfiguration.class)
.env("spring.activemq.inMemory:false").load(context -> {
JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);
ActiveMQConnectionFactory connectionFactory = context
.getBean(ActiveMQConnectionFactory.class);
assertThat(jmsTemplate).isNotNull();
assertThat(connectionFactory).isNotNull();
assertThat(connectionFactory).isEqualTo(jmsTemplate.getConnectionFactory());
assertThat(((ActiveMQConnectionFactory) jmsTemplate.getConnectionFactory())
.getBrokerURL()).isEqualTo(ACTIVEMQ_NETWORK_URL);
});
JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);
ActiveMQConnectionFactory connectionFactory = context
.getBean(ActiveMQConnectionFactory.class);
assertThat(jmsTemplate).isNotNull();
assertThat(connectionFactory).isNotNull();
assertThat(connectionFactory)
.isEqualTo(jmsTemplate.getConnectionFactory());
assertThat(((ActiveMQConnectionFactory) jmsTemplate
.getConnectionFactory()).getBrokerURL())
.isEqualTo(ACTIVEMQ_NETWORK_URL);
});
}
@Test
public void testActiveMQOverriddenRemoteHost() {
this.contextLoader.config(TestConfiguration.class)
.env("spring.activemq.brokerUrl:tcp://remote-host:10000").load(context -> {
JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);
ActiveMQConnectionFactory connectionFactory = context
.getBean(ActiveMQConnectionFactory.class);
assertThat(jmsTemplate).isNotNull();
assertThat(connectionFactory).isNotNull();
assertThat(connectionFactory).isEqualTo(jmsTemplate.getConnectionFactory());
assertThat(((ActiveMQConnectionFactory) jmsTemplate.getConnectionFactory())
.getBrokerURL()).isEqualTo("tcp://remote-host:10000");
});
.env("spring.activemq.brokerUrl:tcp://remote-host:10000")
.load(context -> {
JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);
ActiveMQConnectionFactory connectionFactory = context
.getBean(ActiveMQConnectionFactory.class);
assertThat(jmsTemplate).isNotNull();
assertThat(connectionFactory).isNotNull();
assertThat(connectionFactory)
.isEqualTo(jmsTemplate.getConnectionFactory());
assertThat(((ActiveMQConnectionFactory) jmsTemplate
.getConnectionFactory()).getBrokerURL())
.isEqualTo("tcp://remote-host:10000");
});
}
@Test
public void testActiveMQOverriddenPool() {
this.contextLoader.config(TestConfiguration.class)
.env("spring.activemq.pool.enabled:true").load(context -> {
JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);
PooledConnectionFactory pool = context.getBean(PooledConnectionFactory.class);
assertThat(jmsTemplate).isNotNull();
assertThat(pool).isNotNull();
assertThat(pool).isEqualTo(jmsTemplate.getConnectionFactory());
ActiveMQConnectionFactory factory = (ActiveMQConnectionFactory) pool
.getConnectionFactory();
assertThat(factory.getBrokerURL()).isEqualTo(ACTIVEMQ_EMBEDDED_URL);
});
JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);
PooledConnectionFactory pool = context
.getBean(PooledConnectionFactory.class);
assertThat(jmsTemplate).isNotNull();
assertThat(pool).isNotNull();
assertThat(pool).isEqualTo(jmsTemplate.getConnectionFactory());
ActiveMQConnectionFactory factory = (ActiveMQConnectionFactory) pool
.getConnectionFactory();
assertThat(factory.getBrokerURL()).isEqualTo(ACTIVEMQ_EMBEDDED_URL);
});
}
@Test
public void testActiveMQOverriddenPoolAndStandalone() {
this.contextLoader.config(TestConfiguration.class)
.env("spring.activemq.pool.enabled:true",
"spring.activemq.inMemory:false").load(context -> {
JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);
PooledConnectionFactory pool = context.getBean(PooledConnectionFactory.class);
assertThat(jmsTemplate).isNotNull();
assertThat(pool).isNotNull();
assertThat(pool).isEqualTo(jmsTemplate.getConnectionFactory());
ActiveMQConnectionFactory factory = (ActiveMQConnectionFactory) pool
.getConnectionFactory();
assertThat(factory.getBrokerURL()).isEqualTo(ACTIVEMQ_NETWORK_URL);
});
"spring.activemq.inMemory:false")
.load(context -> {
JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);
PooledConnectionFactory pool = context
.getBean(PooledConnectionFactory.class);
assertThat(jmsTemplate).isNotNull();
assertThat(pool).isNotNull();
assertThat(pool).isEqualTo(jmsTemplate.getConnectionFactory());
ActiveMQConnectionFactory factory = (ActiveMQConnectionFactory) pool
.getConnectionFactory();
assertThat(factory.getBrokerURL()).isEqualTo(ACTIVEMQ_NETWORK_URL);
});
}
@Test
public void testActiveMQOverriddenPoolAndRemoteServer() {
this.contextLoader.config(TestConfiguration.class).env(
"spring.activemq.pool.enabled:true",
"spring.activemq.brokerUrl:tcp://remote-host:10000").load(context -> {
JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);
PooledConnectionFactory pool = context.getBean(PooledConnectionFactory.class);
assertThat(jmsTemplate).isNotNull();
assertThat(pool).isNotNull();
assertThat(pool).isEqualTo(jmsTemplate.getConnectionFactory());
ActiveMQConnectionFactory factory = (ActiveMQConnectionFactory) pool
.getConnectionFactory();
assertThat(factory.getBrokerURL()).isEqualTo("tcp://remote-host:10000");
});
this.contextLoader.config(TestConfiguration.class)
.env("spring.activemq.pool.enabled:true",
"spring.activemq.brokerUrl:tcp://remote-host:10000")
.load(context -> {
JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);
PooledConnectionFactory pool = context
.getBean(PooledConnectionFactory.class);
assertThat(jmsTemplate).isNotNull();
assertThat(pool).isNotNull();
assertThat(pool).isEqualTo(jmsTemplate.getConnectionFactory());
ActiveMQConnectionFactory factory = (ActiveMQConnectionFactory) pool
.getConnectionFactory();
assertThat(factory.getBrokerURL())
.isEqualTo("tcp://remote-host:10000");
});
}
@Test
public void enableJmsAutomatically() throws Exception {
this.contextLoader.config(NoEnableJmsConfiguration.class).load(context -> {
context.getBean(JmsListenerConfigUtils.JMS_LISTENER_ANNOTATION_PROCESSOR_BEAN_NAME);
context.getBean(JmsListenerConfigUtils.JMS_LISTENER_ENDPOINT_REGISTRY_BEAN_NAME);
context.getBean(
JmsListenerConfigUtils.JMS_LISTENER_ANNOTATION_PROCESSOR_BEAN_NAME);
context.getBean(
JmsListenerConfigUtils.JMS_LISTENER_ENDPOINT_REGISTRY_BEAN_NAME);
});
}

74
spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jms/activemq/ActiveMQAutoConfigurationTests.java
View File

@ -25,6 +25,7 @@ import org.junit.Test;
import org.springframework.boot.autoconfigure.jms.JmsAutoConfiguration;
import org.springframework.boot.test.context.ContextLoader;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@ -41,60 +42,71 @@ import static org.mockito.Mockito.mockingDetails;
*/
public class ActiveMQAutoConfigurationTests {
private final ContextLoader contextLoader = new ContextLoader().autoConfig(
ActiveMQAutoConfiguration.class, JmsAutoConfiguration.class);
private final ContextLoader<AnnotationConfigApplicationContext> contextLoader = ContextLoader
.standard()
.autoConfig(ActiveMQAutoConfiguration.class, JmsAutoConfiguration.class);
@Test
public void brokerIsEmbeddedByDefault() {
this.contextLoader.config(EmptyConfiguration.class).load(context -> {
ConnectionFactory connectionFactory = context.getBean(ConnectionFactory.class);
ConnectionFactory connectionFactory = context
.getBean(ConnectionFactory.class);
assertThat(connectionFactory).isInstanceOf(ActiveMQConnectionFactory.class);
String brokerUrl = ((ActiveMQConnectionFactory) connectionFactory).getBrokerURL();
String brokerUrl = ((ActiveMQConnectionFactory) connectionFactory)
.getBrokerURL();
assertThat(brokerUrl).isEqualTo("vm://localhost?broker.persistent=false");
});
}
@Test
public void configurationBacksOffWhenCustomConnectionFactoryExists() {
this.contextLoader.config(CustomConnectionFactoryConfiguration.class).load(
context -> assertThat(mockingDetails(context
.getBean(ConnectionFactory.class)).isMock()).isTrue());
this.contextLoader.config(CustomConnectionFactoryConfiguration.class)
.load(context -> assertThat(
mockingDetails(context.getBean(ConnectionFactory.class)).isMock())
.isTrue());
}
@Test
public void customPooledConnectionFactoryConfiguration() {
this.contextLoader.config(EmptyConfiguration.class).env(
"spring.activemq.pool.enabled:true",
"spring.activemq.pool.maxConnections:256",
"spring.activemq.pool.idleTimeout:512",
"spring.activemq.pool.expiryTimeout:4096",
"spring.activemq.pool.configuration.maximumActiveSessionPerConnection:1024",
"spring.activemq.pool.configuration.timeBetweenExpirationCheckMillis:2048").load(context -> {
ConnectionFactory connectionFactory = context.getBean(ConnectionFactory.class);
assertThat(connectionFactory).isInstanceOf(PooledConnectionFactory.class);
PooledConnectionFactory pooledConnectionFactory = (PooledConnectionFactory) connectionFactory;
assertThat(pooledConnectionFactory.getMaxConnections()).isEqualTo(256);
assertThat(pooledConnectionFactory.getIdleTimeout()).isEqualTo(512);
assertThat(pooledConnectionFactory.getMaximumActiveSessionPerConnection())
.isEqualTo(1024);
assertThat(pooledConnectionFactory.getTimeBetweenExpirationCheckMillis())
.isEqualTo(2048);
assertThat(pooledConnectionFactory.getExpiryTimeout()).isEqualTo(4096);
});
this.contextLoader.config(EmptyConfiguration.class)
.env("spring.activemq.pool.enabled:true",
"spring.activemq.pool.maxConnections:256",
"spring.activemq.pool.idleTimeout:512",
"spring.activemq.pool.expiryTimeout:4096",
"spring.activemq.pool.configuration.maximumActiveSessionPerConnection:1024",
"spring.activemq.pool.configuration.timeBetweenExpirationCheckMillis:2048")
.load(context -> {
ConnectionFactory connectionFactory = context
.getBean(ConnectionFactory.class);
assertThat(connectionFactory)
.isInstanceOf(PooledConnectionFactory.class);
PooledConnectionFactory pooledConnectionFactory = (PooledConnectionFactory) connectionFactory;
assertThat(pooledConnectionFactory.getMaxConnections())
.isEqualTo(256);
assertThat(pooledConnectionFactory.getIdleTimeout()).isEqualTo(512);
assertThat(pooledConnectionFactory
.getMaximumActiveSessionPerConnection()).isEqualTo(1024);
assertThat(
pooledConnectionFactory.getTimeBetweenExpirationCheckMillis())
.isEqualTo(2048);
assertThat(pooledConnectionFactory.getExpiryTimeout())
.isEqualTo(4096);
});
}
@Test
public void pooledConnectionFactoryConfiguration() throws JMSException {
this.contextLoader.config(EmptyConfiguration.class)
.env("spring.activemq.pool.enabled:true").load(context -> {
ConnectionFactory connectionFactory = context.getBean(ConnectionFactory.class);
assertThat(connectionFactory).isInstanceOf(PooledConnectionFactory.class);
context.close();
assertThat(connectionFactory.createConnection()).isNull();
});
ConnectionFactory connectionFactory = context
.getBean(ConnectionFactory.class);
assertThat(connectionFactory)
.isInstanceOf(PooledConnectionFactory.class);
context.close();
assertThat(connectionFactory.createConnection()).isNull();
});
}
@Configuration
static class EmptyConfiguration {

204
spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jms/artemis/ArtemisAutoConfigurationTests.java
View File

@ -44,6 +44,7 @@ import org.junit.rules.TemporaryFolder;
import org.springframework.boot.autoconfigure.jms.JmsAutoConfiguration;
import org.springframework.boot.test.context.ContextLoader;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jms.core.JmsTemplate;
@ -65,64 +66,72 @@ public class ArtemisAutoConfigurationTests {
@Rule
public final TemporaryFolder folder = new TemporaryFolder();
private final ContextLoader contextLoader = new ContextLoader().autoConfig(
ArtemisAutoConfiguration.class, JmsAutoConfiguration.class);
private final ContextLoader<AnnotationConfigApplicationContext> contextLoader = ContextLoader
.standard()
.autoConfig(ArtemisAutoConfiguration.class, JmsAutoConfiguration.class);
@Test
public void nativeConnectionFactory() {
this.contextLoader.config(EmptyConfiguration.class)
.env("spring.artemis.mode:native").load(context -> {
JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);
ActiveMQConnectionFactory connectionFactory = context
.getBean(ActiveMQConnectionFactory.class);
assertThat(connectionFactory).isEqualTo(jmsTemplate.getConnectionFactory());
assertNettyConnectionFactory(connectionFactory, "localhost", 61616);
assertThat(connectionFactory.getUser()).isNull();
assertThat(connectionFactory.getPassword()).isNull();
});
JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);
ActiveMQConnectionFactory connectionFactory = context
.getBean(ActiveMQConnectionFactory.class);
assertThat(connectionFactory)
.isEqualTo(jmsTemplate.getConnectionFactory());
assertNettyConnectionFactory(connectionFactory, "localhost", 61616);
assertThat(connectionFactory.getUser()).isNull();
assertThat(connectionFactory.getPassword()).isNull();
});
}
@Test
public void nativeConnectionFactoryCustomHost() {
this.contextLoader.config(EmptyConfiguration.class)
.env("spring.artemis.mode:native", "spring.artemis.host:192.168.1.144",
"spring.artemis.port:9876").load(context -> {
ActiveMQConnectionFactory connectionFactory = context
.getBean(ActiveMQConnectionFactory.class);
assertNettyConnectionFactory(connectionFactory, "192.168.1.144", 9876);
});
this.contextLoader
.config(EmptyConfiguration.class).env("spring.artemis.mode:native",
"spring.artemis.host:192.168.1.144", "spring.artemis.port:9876")
.load(context -> {
ActiveMQConnectionFactory connectionFactory = context
.getBean(ActiveMQConnectionFactory.class);
assertNettyConnectionFactory(connectionFactory, "192.168.1.144",
9876);
});
}
@Test
public void nativeConnectionFactoryCredentials() {
this.contextLoader.config(EmptyConfiguration.class)
.env("spring.artemis.mode:native", "spring.artemis.user:user",
"spring.artemis.password:secret").load(context -> {
JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);
ActiveMQConnectionFactory connectionFactory = context
.getBean(ActiveMQConnectionFactory.class);
assertThat(connectionFactory).isEqualTo(jmsTemplate.getConnectionFactory());
assertNettyConnectionFactory(connectionFactory, "localhost", 61616);
assertThat(connectionFactory.getUser()).isEqualTo("user");
assertThat(connectionFactory.getPassword()).isEqualTo("secret");
});
this.contextLoader
.config(EmptyConfiguration.class).env("spring.artemis.mode:native",
"spring.artemis.user:user", "spring.artemis.password:secret")
.load(context -> {
JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);
ActiveMQConnectionFactory connectionFactory = context
.getBean(ActiveMQConnectionFactory.class);
assertThat(connectionFactory)
.isEqualTo(jmsTemplate.getConnectionFactory());
assertNettyConnectionFactory(connectionFactory, "localhost", 61616);
assertThat(connectionFactory.getUser()).isEqualTo("user");
assertThat(connectionFactory.getPassword()).isEqualTo("secret");
});
}
@Test
public void embeddedConnectionFactory() {
this.contextLoader.config(EmptyConfiguration.class)
.env("spring.artemis.mode:embedded").load(context -> {
ArtemisProperties properties = context.getBean(ArtemisProperties.class);
assertThat(properties.getMode()).isEqualTo(ArtemisMode.EMBEDDED);
assertThat(context.getBeansOfType(EmbeddedJMS.class)).hasSize(1);
org.apache.activemq.artemis.core.config.Configuration configuration = context
.getBean(org.apache.activemq.artemis.core.config.Configuration.class);
assertThat(configuration.isPersistenceEnabled()).isFalse();
assertThat(configuration.isSecurityEnabled()).isFalse();
ActiveMQConnectionFactory connectionFactory = context
.getBean(ActiveMQConnectionFactory.class);
assertInVmConnectionFactory(connectionFactory);
});
ArtemisProperties properties = context
.getBean(ArtemisProperties.class);
assertThat(properties.getMode()).isEqualTo(ArtemisMode.EMBEDDED);
assertThat(context.getBeansOfType(EmbeddedJMS.class)).hasSize(1);
org.apache.activemq.artemis.core.config.Configuration configuration = context
.getBean(
org.apache.activemq.artemis.core.config.Configuration.class);
assertThat(configuration.isPersistenceEnabled()).isFalse();
assertThat(configuration.isSecurityEnabled()).isFalse();
ActiveMQConnectionFactory connectionFactory = context
.getBean(ActiveMQConnectionFactory.class);
assertInVmConnectionFactory(connectionFactory);
});
}
@Test
@ -146,11 +155,11 @@ public class ArtemisAutoConfigurationTests {
// No mode is specified
this.contextLoader.config(EmptyConfiguration.class)
.env("spring.artemis.embedded.enabled:false").load(context -> {
assertThat(context.getBeansOfType(EmbeddedJMS.class)).isEmpty();
ActiveMQConnectionFactory connectionFactory = context
.getBean(ActiveMQConnectionFactory.class);
assertNettyConnectionFactory(connectionFactory, "localhost", 61616);
});
assertThat(context.getBeansOfType(EmbeddedJMS.class)).isEmpty();
ActiveMQConnectionFactory connectionFactory = context
.getBean(ActiveMQConnectionFactory.class);
assertNettyConnectionFactory(connectionFactory, "localhost", 61616);
});
}
@Test
@ -158,26 +167,28 @@ public class ArtemisAutoConfigurationTests {
// No mode is specified
this.contextLoader.config(EmptyConfiguration.class)
.env("spring.artemis.mode:embedded",
"spring.artemis.embedded.enabled:false").load(context -> {
assertThat(context.getBeansOfType(EmbeddedJMS.class)).isEmpty();
ActiveMQConnectionFactory connectionFactory = context
.getBean(ActiveMQConnectionFactory.class);
assertInVmConnectionFactory(connectionFactory);
});
"spring.artemis.embedded.enabled:false")
.load(context -> {
assertThat(context.getBeansOfType(EmbeddedJMS.class)).isEmpty();
ActiveMQConnectionFactory connectionFactory = context
.getBean(ActiveMQConnectionFactory.class);
assertInVmConnectionFactory(connectionFactory);
});
}
@Test
public void embeddedServerWithDestinations() {
this.contextLoader.config(EmptyConfiguration.class)
.env("spring.artemis.embedded.queues=Queue1,Queue2",
"spring.artemis.embedded.topics=Topic1").load(context -> {
DestinationChecker checker = new DestinationChecker(context);
checker.checkQueue("Queue1", true);
checker.checkQueue("Queue2", true);
checker.checkQueue("QueueWillNotBeAutoCreated", true);
checker.checkTopic("Topic1", true);
checker.checkTopic("TopicWillBeAutoCreated", true);
});
"spring.artemis.embedded.topics=Topic1")
.load(context -> {
DestinationChecker checker = new DestinationChecker(context);
checker.checkQueue("Queue1", true);
checker.checkQueue("Queue2", true);
checker.checkQueue("QueueWillNotBeAutoCreated", true);
checker.checkTopic("Topic1", true);
checker.checkTopic("TopicWillBeAutoCreated", true);
});
}
@Test
@ -194,11 +205,11 @@ public class ArtemisAutoConfigurationTests {
// Ignored with custom config
this.contextLoader.config(CustomJmsConfiguration.class)
.env("spring.artemis.embedded.queues=Queue1,Queue2").load(context -> {
DestinationChecker checker = new DestinationChecker(context);
checker.checkQueue("custom", true); // See CustomJmsConfiguration
checker.checkQueue("Queue1", true);
checker.checkQueue("Queue2", true);
});
DestinationChecker checker = new DestinationChecker(context);
checker.checkQueue("custom", true); // See CustomJmsConfiguration
checker.checkQueue("Queue1", true);
checker.checkQueue("Queue2", true);
});
}
@Test
@ -216,8 +227,7 @@ public class ArtemisAutoConfigurationTests {
final String msgId = UUID.randomUUID().toString();
// Start the server and post a message to some queue
this.contextLoader
.config(EmptyConfiguration.class).env(
this.contextLoader.config(EmptyConfiguration.class).env(
"spring.artemis.embedded.queues=TestQueue",
"spring.artemis.embedded.persistent:true",
"spring.artemis.embedded.dataDirectory:" + dataFolder.getAbsolutePath())
@ -226,7 +236,8 @@ public class ArtemisAutoConfigurationTests {
JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);
jmsTemplate.send("TestQueue", new MessageCreator() {
@Override
public Message createMessage(Session session) throws JMSException {
public Message createMessage(Session session)
throws JMSException {
return session.createTextMessage(msgId);
}
});
@ -245,41 +256,54 @@ public class ArtemisAutoConfigurationTests {
@Test
public void severalEmbeddedBrokers() {
this.contextLoader.config(EmptyConfiguration.class).env(
"spring.artemis.embedded.queues=Queue1").load(rootContext -> {
this.contextLoader.env("spring.artemis.embedded.queues=Queue2").load(anotherContext -> {
ArtemisProperties properties = rootContext.getBean(ArtemisProperties.class);
ArtemisProperties anotherProperties = anotherContext
.getBean(ArtemisProperties.class);
assertThat(properties.getEmbedded().getServerId() < anotherProperties
.getEmbedded().getServerId()).isTrue();
DestinationChecker checker = new DestinationChecker(anotherContext);
checker.checkQueue("Queue1", true);
checker.checkQueue("Queue2", true);
DestinationChecker anotherChecker = new DestinationChecker(anotherContext);
anotherChecker.checkQueue("Queue2", true);
anotherChecker.checkQueue("Queue1", true);
});
});
this.contextLoader.config(EmptyConfiguration.class)
.env("spring.artemis.embedded.queues=Queue1").load(rootContext -> {
this.contextLoader.env("spring.artemis.embedded.queues=Queue2")
.load(anotherContext -> {
ArtemisProperties properties = rootContext
.getBean(ArtemisProperties.class);
ArtemisProperties anotherProperties = anotherContext
.getBean(ArtemisProperties.class);
assertThat(
properties.getEmbedded().getServerId() < anotherProperties
.getEmbedded().getServerId()).isTrue();
DestinationChecker checker = new DestinationChecker(
anotherContext);
checker.checkQueue("Queue1", true);
checker.checkQueue("Queue2", true);
DestinationChecker anotherChecker = new DestinationChecker(
anotherContext);
anotherChecker.checkQueue("Queue2", true);
anotherChecker.checkQueue("Queue1", true);
});
});
}
@Test
public void connectToASpecificEmbeddedBroker() {
this.contextLoader.config(EmptyConfiguration.class)
.env("spring.artemis.embedded.serverId=93",
"spring.artemis.embedded.queues=Queue1").load(context -> {
this.contextLoader.config(EmptyConfiguration.class).env(
"spring.artemis.mode=embedded",
"spring.artemis.embedded.serverId=93", /* Connect to the "main" broker */
"spring.artemis.embedded.enabled=false" /* do not start a specific one */)
.load(anotherContext -> {
"spring.artemis.embedded.queues=Queue1")
.load(context -> {
this.contextLoader.config(EmptyConfiguration.class).env(
"spring.artemis.mode=embedded",
"spring.artemis.embedded.serverId=93", /*
* Connect to the
* "main" broker
*/
"spring.artemis.embedded.enabled=false" /*
* do not start a
* specific one
*/)
.load(anotherContext -> {
DestinationChecker checker = new DestinationChecker(context);
checker.checkQueue("Queue1", true);
DestinationChecker anotherChecker = new DestinationChecker(anotherContext);
DestinationChecker anotherChecker = new DestinationChecker(
anotherContext);
anotherChecker.checkQueue("Queue1", true);
});
});
});
}
private TransportConfiguration assertInVmConnectionFactory(

5
spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/web/reactive/HttpHandlerAutoConfigurationTests.java
View File

@ -19,6 +19,7 @@ package org.springframework.boot.autoconfigure.web.reactive;
import org.junit.Test;
import org.springframework.boot.test.context.ContextLoader;
import org.springframework.boot.web.reactive.context.GenericReactiveWebApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.server.reactive.HttpHandler;
@ -38,8 +39,8 @@ import static org.assertj.core.api.Assertions.assertThat;
*/
public class HttpHandlerAutoConfigurationTests {
private final ContextLoader contextLoader = new ContextLoader().webReactive()
.autoConfig(HttpHandlerAutoConfiguration.class);
private final ContextLoader<GenericReactiveWebApplicationContext> contextLoader = ContextLoader
.reactiveWeb().autoConfig(HttpHandlerAutoConfiguration.class);
@Test
public void shouldNotProcessIfExistingHttpHandler() {

27
spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/web/servlet/WebMvcAutoConfigurationTests.java
View File

@ -61,7 +61,7 @@ import org.springframework.validation.Validator;
import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;
import org.springframework.web.accept.ContentNegotiationManager;
import org.springframework.web.bind.support.ConfigurableWebBindingInitializer;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.filter.HttpPutFormContentFilter;
import org.springframework.web.servlet.HandlerAdapter;
import org.springframework.web.servlet.HandlerExceptionResolver;
@ -114,11 +114,12 @@ public class WebMvcAutoConfigurationTests {
private static final MockServletWebServerFactory webServerFactory = new MockServletWebServerFactory();
private final ContextLoader contextLoader = new ContextLoader()
private final ContextLoader<AnnotationConfigWebApplicationContext> contextLoader = ContextLoader
.servletWeb()
.autoConfig(WebMvcAutoConfiguration.class,
HttpMessageConvertersAutoConfiguration.class,
PropertyPlaceholderAutoConfiguration.class)
.config(Config.class).webServlet();
.config(Config.class);
@Test
public void handlerAdaptersCreated() {
@ -574,11 +575,10 @@ public class WebMvcAutoConfigurationTests {
public void welcomePageMappingProducesNotFoundResponseWhenThereIsNoWelcomePage() {
this.contextLoader
.env("spring.resources.static-locations:classpath:/no-welcome-page/");
this.contextLoader.webServlet().load(context -> {
this.contextLoader.load(context -> {
assertThat(context.getBeansOfType(WelcomePageHandlerMapping.class))
.hasSize(1);
// TODO This cast is ugly. Fix it with generics and ContextLoader subclasses
MockMvcBuilders.webAppContextSetup((WebApplicationContext) context).build()
MockMvcBuilders.webAppContextSetup(context).build()
.perform(get("/").accept(MediaType.TEXT_HTML))
.andExpect(status().isNotFound());
});
@ -603,8 +603,7 @@ public class WebMvcAutoConfigurationTests {
this.contextLoader.load(context -> {
assertThat(context.getBeansOfType(WelcomePageHandlerMapping.class))
.hasSize(1);
MockMvc mockMvc = MockMvcBuilders
.webAppContextSetup((WebApplicationContext) context).build();
MockMvc mockMvc = MockMvcBuilders.webAppContextSetup(context).build();
mockMvc.perform(get("/").accept(MediaType.TEXT_HTML))
.andExpect(status().isOk()).andExpect(forwardedUrl("index.html"));
mockMvc.perform(get("/").accept("*/*")).andExpect(status().isOk())
@ -619,8 +618,7 @@ public class WebMvcAutoConfigurationTests {
this.contextLoader.load(context -> {
assertThat(context.getBeansOfType(WelcomePageHandlerMapping.class))
.hasSize(1);
MockMvc mockMvc = MockMvcBuilders
.webAppContextSetup((WebApplicationContext) context).build();
MockMvc mockMvc = MockMvcBuilders.webAppContextSetup(context).build();
mockMvc.perform(get("/").accept(MediaType.APPLICATION_JSON))
.andExpect(status().isNotFound());
});
@ -633,8 +631,7 @@ public class WebMvcAutoConfigurationTests {
this.contextLoader.load(context -> {
assertThat(context.getBeansOfType(WelcomePageHandlerMapping.class))
.hasSize(1);
MockMvc mockMvc = MockMvcBuilders
.webAppContextSetup((WebApplicationContext) context).build();
MockMvc mockMvc = MockMvcBuilders.webAppContextSetup(context).build();
mockMvc.perform(get("/")).andExpect(status().isOk())
.andExpect(forwardedUrl("index.html"));
});
@ -648,8 +645,7 @@ public class WebMvcAutoConfigurationTests {
this.contextLoader.load(context -> {
assertThat(context.getBeansOfType(WelcomePageHandlerMapping.class))
.hasSize(1);
MockMvc mockMvc = MockMvcBuilders
.webAppContextSetup((WebApplicationContext) context).build();
MockMvc mockMvc = MockMvcBuilders.webAppContextSetup(context).build();
mockMvc.perform(get("/").header(HttpHeaders.ACCEPT, ""))
.andExpect(status().isOk()).andExpect(forwardedUrl("index.html"));
});
@ -663,8 +659,7 @@ public class WebMvcAutoConfigurationTests {
this.contextLoader.load(context -> {
assertThat(context.getBeansOfType(WelcomePageHandlerMapping.class))
.hasSize(1);
MockMvc mockMvc = MockMvcBuilders
.webAppContextSetup((WebApplicationContext) context).build();
MockMvc mockMvc = MockMvcBuilders.webAppContextSetup(context).build();
mockMvc.perform(get("/").accept(MediaType.TEXT_HTML))
.andExpect(status().isOk()).andExpect(forwardedUrl("index.html"));
});

5
spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/webservices/WebServicesAutoConfigurationTests.java
View File

@ -24,6 +24,7 @@ import org.springframework.beans.factory.BeanCreationException;
import org.springframework.boot.test.context.ContextLoader;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.test.util.ReflectionTestUtils;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import static org.assertj.core.api.Assertions.assertThat;
@ -36,8 +37,8 @@ import static org.assertj.core.api.Assertions.assertThat;
*/
public class WebServicesAutoConfigurationTests {
private final ContextLoader contextLoader = new ContextLoader().webServlet()
.autoConfig(WebServicesAutoConfiguration.class);
private final ContextLoader<AnnotationConfigWebApplicationContext> contextLoader = ContextLoader
.servletWeb().autoConfig(WebServicesAutoConfiguration.class);
@Rule
public ExpectedException thrown = ExpectedException.none();

5
spring-boot-test-autoconfigure/src/test/java/org/springframework/boot/test/autoconfigure/jdbc/TestDatabaseAutoConfigurationTests.java
View File

@ -21,6 +21,7 @@ import javax.sql.DataSource;
import org.junit.Test;
import org.springframework.boot.test.context.ContextLoader;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
@ -37,8 +38,8 @@ import static org.assertj.core.api.Assertions.assertThat;
*/
public class TestDatabaseAutoConfigurationTests {
private final ContextLoader contextLoader = new ContextLoader()
.autoConfig(TestDatabaseAutoConfiguration.class);
private final ContextLoader<AnnotationConfigApplicationContext> contextLoader = ContextLoader
.standard().autoConfig(TestDatabaseAutoConfiguration.class);
@Test
public void replaceWithNoDataSourceAvailable() {

5
spring-boot-test-autoconfigure/src/test/java/org/springframework/boot/test/autoconfigure/orm/jpa/TestDatabaseAutoConfigurationNoEmbeddedTests.java
View File

@ -26,6 +26,7 @@ import org.springframework.boot.test.autoconfigure.jdbc.TestDatabaseAutoConfigur
import org.springframework.boot.test.context.ContextLoader;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@ -43,8 +44,8 @@ import static org.mockito.Mockito.mock;
@ClassPathExclusions({ "h2-*.jar", "hsqldb-*.jar", "derby-*.jar" })
public class TestDatabaseAutoConfigurationNoEmbeddedTests {
private final ContextLoader contextLoader = new ContextLoader()
.config(ExistingDataSourceConfiguration.class)
private final ContextLoader<AnnotationConfigApplicationContext> contextLoader = ContextLoader
.standard().config(ExistingDataSourceConfiguration.class)
.autoConfig(TestDatabaseAutoConfiguration.class);
@Test

11
spring-boot-test/src/main/java/org/springframework/boot/test/context/ContextConsumer.java
View File

@ -20,22 +20,21 @@ import org.springframework.context.ConfigurableApplicationContext;
/**
* Callback interface used in tests to process a running
* {@link ConfigurableApplicationContext} with the ability to throw a (checked)
* exception.
* {@link ConfigurableApplicationContext} with the ability to throw a (checked) exception.
*
* @author Stephane Nicoll
* @author Andy Wilkinson
* @since 2.0.0
* @param <T> the type of the context that can be consumed
*/
@FunctionalInterface
public interface ContextConsumer {
public interface ContextConsumer<T extends ConfigurableApplicationContext> {
/**
* Performs this operation on the supplied {@link ConfigurableApplicationContext
* ApplicationContext}.
* Performs this operation on the supplied {@code context}.
* @param context the application context to consume
* @throws Throwable any exception that might occur in assertions
*/
void accept(ConfigurableApplicationContext context) throws Throwable;
void accept(T context) throws Throwable;
}

249
spring-boot-test/src/main/java/org/springframework/boot/test/context/ContextLoader.java
View File

@ -16,32 +16,15 @@
package org.springframework.boot.test.context;
import java.io.Closeable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Consumer;
import java.util.function.Supplier;
import org.springframework.boot.test.util.TestPropertyValues;
import org.springframework.boot.web.reactive.context.GenericReactiveWebApplicationContext;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.AnnotationConfigRegistry;
import org.springframework.core.io.DefaultResourceLoader;
import org.springframework.mock.web.MockServletContext;
import org.springframework.util.Assert;
import org.springframework.util.ObjectUtils;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Manage the lifecycle of an {@link ApplicationContext}. Such helper is best used as a
* field of a test class, describing the shared configuration required for the test:
@ -91,20 +74,45 @@ import static org.assertj.core.api.Assertions.assertThat;
* @author Stephane Nicoll
* @author Andy Wilkinson
* @since 2.0.0
* @param <T> the type of the context to be loaded
*/
public class ContextLoader {
public interface ContextLoader<T extends ConfigurableApplicationContext> {
private final Map<String, String> systemProperties = new HashMap<>();
/**
* Creates a {@code ContextLoader} that will load a standard
* {@link AnnotationConfigApplicationContext}.
*
* @return the context loader
*/
static ContextLoader<AnnotationConfigApplicationContext> standard() {
return new StandardContextLoader<>(
() -> new AnnotationConfigApplicationContext());
}
private final List<String> env = new ArrayList<>();
/**
* Creates a {@code ContextLoader} that will load a
* {@link AnnotationConfigWebApplicationContext}.
*
* @return the context loader
*/
static ContextLoader<AnnotationConfigWebApplicationContext> servletWeb() {
return new StandardContextLoader<>(() -> {
AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
context.setServletContext(new MockServletContext());
return context;
});
}
private final Set<Class<?>> userConfigurations = new LinkedHashSet<>();
private final LinkedList<Class<?>> autoConfigurations = new LinkedList<>();
private Supplier<ConfigurableApplicationContext> contextSupplier = () -> new AnnotationConfigApplicationContext();
private ClassLoader classLoader;
/**
* Creates a {@code ContextLoader} that will load a
* {@link GenericReactiveWebApplicationContext}.
*
* @return the context loader
*/
static ContextLoader<GenericReactiveWebApplicationContext> reactiveWeb() {
return new StandardContextLoader<>(
() -> new GenericReactiveWebApplicationContext());
}
/**
* Set the specified system property prior to loading the context and restore its
@ -114,16 +122,7 @@ public class ContextLoader {
* @param value the value (can be null to remove any existing customization)
* @return this instance
*/
public ContextLoader systemProperty(String key, String value) {
Assert.notNull(key, "Key must not be null");
if (value != null) {
this.systemProperties.put(key, value);
}
else {
this.systemProperties.remove(key);
}
return this;
}
public ContextLoader<T> systemProperty(String key, String value);
/**
* Add the specified property pairs. Key-value pairs can be specified with colon (":")
@ -133,36 +132,21 @@ public class ContextLoader {
* environment
* @return this instance
*/
public ContextLoader env(String... pairs) {
if (!ObjectUtils.isEmpty(pairs)) {
this.env.addAll(Arrays.asList(pairs));
}
return this;
}
public ContextLoader<T> env(String... pairs);
/**
* Add the specified user configuration classes.
* @param configs the user configuration classes to add
* @return this instance
*/
public ContextLoader config(Class<?>... configs) {
if (!ObjectUtils.isEmpty(configs)) {
this.userConfigurations.addAll(Arrays.asList(configs));
}
return this;
}
public ContextLoader<T> config(Class<?>... configs);
/**
* Add the specified auto-configuration classes.
* @param autoConfigurations the auto-configuration classes to add
* @return this instance
*/
public ContextLoader autoConfig(Class<?>... autoConfigurations) {
if (!ObjectUtils.isEmpty(autoConfigurations)) {
this.autoConfigurations.addAll(Arrays.asList(autoConfigurations));
}
return this;
}
public ContextLoader<T> autoConfig(Class<?>... autoConfigurations);
/**
* Add the specified auto-configurations at the beginning (in that order) so that it
@ -172,10 +156,7 @@ public class ContextLoader {
* @param autoConfigurations the auto-configuration to add
* @return this instance
*/
public ContextLoader autoConfigFirst(Class<?>... autoConfigurations) {
this.autoConfigurations.addAll(0, Arrays.asList(autoConfigurations));
return this;
}
public ContextLoader<T> autoConfigFirst(Class<?>... autoConfigurations);
/**
* Customize the {@link ClassLoader} that the {@link ApplicationContext} should use.
@ -185,58 +166,15 @@ public class ContextLoader {
* @return this instance
* @see HidePackagesClassLoader
*/
public ContextLoader classLoader(ClassLoader classLoader) {
this.classLoader = classLoader;
return this;
}
/**
* Configures the loader to create an {@link ApplicationContext} suitable for use in a
* reactive web application.
* @return this instance
*/
public ContextLoader webReactive() {
this.contextSupplier = () -> {
return new GenericReactiveWebApplicationContext();
};
return this;
}
/**
* Configures the loader to create an {@link ApplicationContext} suitable for use in a
* servlet web application.
* @return this instance
*/
public ContextLoader webServlet() {
this.contextSupplier = () -> {
AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
context.setServletContext(new MockServletContext());
return context;
};
return this;
}
public ContextLoader<T> classLoader(ClassLoader classLoader);
/**
* Create and refresh a new {@link ApplicationContext} based on the current state of
* this loader. The context is consumed by the specified {@link ContextConsumer} and
* closed upon completion.
* this loader. The context is consumed by the specified {@code consumers} and closed
* upon completion.
* @param consumer the consumer of the created {@link ApplicationContext}
*/
public void load(ContextConsumer consumer) {
try (ApplicationContextLifecycleHandler handler = new ApplicationContextLifecycleHandler()) {
try {
ConfigurableApplicationContext ctx = handler.load();
consumer.accept(ctx);
}
catch (RuntimeException ex) {
throw ex;
}
catch (Throwable ex) {
throw new IllegalStateException(
"An unexpected error occurred: " + ex.getMessage(), ex);
}
}
}
public void load(ContextConsumer<T> consumer);
/**
* Create and refresh a new {@link ApplicationContext} based on the current state of
@ -245,9 +183,7 @@ public class ContextLoader {
* specified {@link Consumer} with no expectation on the type of the exception.
* @param consumer the consumer of the failure
*/
public void loadAndFail(Consumer<Throwable> consumer) {
loadAndFail(Throwable.class, consumer);
}
public void loadAndFail(Consumer<Throwable> consumer);
/**
* Create and refresh a new {@link ApplicationContext} based on the current state of
@ -257,98 +193,9 @@ public class ContextLoader {
* exception type matches, it is consumed by the specified {@link Consumer}.
* @param exceptionType the expected type of the failure
* @param consumer the consumer of the failure
* @param <T> the expected type of the failure
* @param <E> the expected type of the failure
*/
public <T extends Throwable> void loadAndFail(Class<T> exceptionType,
Consumer<T> consumer) {
try (ApplicationContextLifecycleHandler handler = new ApplicationContextLifecycleHandler()) {
handler.load();
throw new AssertionError("ApplicationContext should have failed");
}
catch (Throwable ex) {
assertThat(ex).as("Wrong application context failure exception")
.isInstanceOf(exceptionType);
consumer.accept(exceptionType.cast(ex));
}
}
private ConfigurableApplicationContext createApplicationContext() {
ConfigurableApplicationContext context = ContextLoader.this.contextSupplier.get();
if (this.classLoader != null) {
((DefaultResourceLoader) context).setClassLoader(this.classLoader);
}
if (!ObjectUtils.isEmpty(this.env)) {
TestPropertyValues.of(this.env.toArray(new String[this.env.size()]))
.applyTo(context);
}
AnnotationConfigRegistry registry = ((AnnotationConfigRegistry) context);
if (!ObjectUtils.isEmpty(this.userConfigurations)) {
registry.register(this.userConfigurations
.toArray(new Class<?>[this.userConfigurations.size()]));
}
if (!ObjectUtils.isEmpty(this.autoConfigurations)) {
LinkedHashSet<Class<?>> linkedHashSet = new LinkedHashSet<>(
this.autoConfigurations);
registry.register(
linkedHashSet.toArray(new Class<?>[this.autoConfigurations.size()]));
}
return context;
}
/**
* Handles the lifecycle of the {@link ApplicationContext}.
*/
private class ApplicationContextLifecycleHandler implements Closeable {
private final Map<String, String> customSystemProperties;
private final Map<String, String> previousSystemProperties = new HashMap<>();
private ConfigurableApplicationContext context;
ApplicationContextLifecycleHandler() {
this.customSystemProperties = new HashMap<>(
ContextLoader.this.systemProperties);
}
public ConfigurableApplicationContext load() {
setCustomSystemProperties();
ConfigurableApplicationContext context = createApplicationContext();
context.refresh();
this.context = context;
return context;
}
@Override
public void close() {
try {
if (this.context != null) {
this.context.close();
}
}
finally {
unsetCustomSystemProperties();
}
}
private void setCustomSystemProperties() {
this.customSystemProperties.forEach((key, value) -> {
String previous = System.setProperty(key, value);
this.previousSystemProperties.put(key, previous);
});
}
private void unsetCustomSystemProperties() {
this.previousSystemProperties.forEach((key, value) -> {
if (value != null) {
System.setProperty(key, value);
}
else {
System.clearProperty(key);
}
});
}
}
public <E extends Throwable> void loadAndFail(Class<E> exceptionType,
Consumer<E> consumer);
}

300
spring-boot-test/src/main/java/org/springframework/boot/test/context/StandardContextLoader.java Normal file
View File

@ -0,0 +1,300 @@
/*
* Copyright 2012-2017 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
*
* http://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.boot.test.context;
import java.io.Closeable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Consumer;
import java.util.function.Supplier;
import org.springframework.boot.test.util.TestPropertyValues;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.AnnotationConfigRegistry;
import org.springframework.core.io.DefaultResourceLoader;
import org.springframework.util.Assert;
import org.springframework.util.ObjectUtils;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Standard implementation of {@link ContextLoader}.
*
* @author Stephane Nicoll
* @author Andy Wilkinson
* @param <T> the type of the context to be loaded
*/
final class StandardContextLoader<T extends ConfigurableApplicationContext & AnnotationConfigRegistry>
implements ContextLoader<T> {
private final Map<String, String> systemProperties = new HashMap<>();
private final List<String> env = new ArrayList<>();
private final Set<Class<?>> userConfigurations = new LinkedHashSet<>();
private final LinkedList<Class<?>> autoConfigurations = new LinkedList<>();
private final Supplier<T> contextSupplier;
private ClassLoader classLoader;
StandardContextLoader(Supplier<T> contextSupplier) {
this.contextSupplier = contextSupplier;
}
/**
* Set the specified system property prior to loading the context and restore its
* previous value once the consumer has been invoked and the context closed. If the
* {@code value} is {@code null} this removes any prior customization for that key.
* @param key the system property
* @param value the value (can be null to remove any existing customization)
* @return this instance
*/
@Override
public StandardContextLoader<T> systemProperty(String key, String value) {
Assert.notNull(key, "Key must not be null");
if (value != null) {
this.systemProperties.put(key, value);
}
else {
this.systemProperties.remove(key);
}
return this;
}
/**
* Add the specified property pairs. Key-value pairs can be specified with colon (":")
* or equals ("=") separators. Override matching keys that might have been specified
* previously.
* @param pairs the key-value pairs for properties that need to be added to the
* environment
* @return this instance
*/
@Override
public StandardContextLoader<T> env(String... pairs) {
if (!ObjectUtils.isEmpty(pairs)) {
this.env.addAll(Arrays.asList(pairs));
}
return this;
}
/**
* Add the specified user configuration classes.
* @param configs the user configuration classes to add
* @return this instance
*/
@Override
public StandardContextLoader<T> config(Class<?>... configs) {
if (!ObjectUtils.isEmpty(configs)) {
this.userConfigurations.addAll(Arrays.asList(configs));
}
return this;
}
/**
* Add the specified auto-configuration classes.
* @param autoConfigurations the auto-configuration classes to add
* @return this instance
*/
@Override
public StandardContextLoader<T> autoConfig(Class<?>... autoConfigurations) {
if (!ObjectUtils.isEmpty(autoConfigurations)) {
this.autoConfigurations.addAll(Arrays.asList(autoConfigurations));
}
return this;
}
/**
* Add the specified auto-configurations at the beginning (in that order) so that it
* is applied before any other existing auto-configurations, but after any user
* configuration. If {@code A} and {@code B} are specified, {@code A} will be
* processed, then {@code B} and finally the rest of the existing auto-configuration.
* @param autoConfigurations the auto-configuration to add
* @return this instance
*/
@Override
public StandardContextLoader<T> autoConfigFirst(Class<?>... autoConfigurations) {
this.autoConfigurations.addAll(0, Arrays.asList(autoConfigurations));
return this;
}
/**
* Customize the {@link ClassLoader} that the {@link ApplicationContext} should use.
* Customizing the {@link ClassLoader} is an effective manner to hide resources from
* the classpath.
* @param classLoader the classloader to use (can be null to use the default)
* @return this instance
* @see HidePackagesClassLoader
*/
@Override
public StandardContextLoader<T> classLoader(ClassLoader classLoader) {
this.classLoader = classLoader;
return this;
}
/**
* Create and refresh a new {@link ApplicationContext} based on the current state of
* this loader. The context is consumed by the specified {@link ContextConsumer} and
* closed upon completion.
* @param consumer the consumer of the created {@link ApplicationContext}
*/
@Override
public void load(ContextConsumer<T> consumer) {
try (ApplicationContextLifecycleHandler handler = new ApplicationContextLifecycleHandler()) {
try {
T ctx = handler.load();
consumer.accept(ctx);
}
catch (RuntimeException ex) {
throw ex;
}
catch (Throwable ex) {
throw new IllegalStateException(
"An unexpected error occurred: " + ex.getMessage(), ex);
}
}
}
/**
* Create and refresh a new {@link ApplicationContext} based on the current state of
* this loader that this expected to fail. If the context does not fail, an
* {@link AssertionError} is thrown. Otherwise the exception is consumed by the
* specified {@link Consumer} with no expectation on the type of the exception.
* @param consumer the consumer of the failure
*/
@Override
public void loadAndFail(Consumer<Throwable> consumer) {
loadAndFail(Throwable.class, consumer);
}
/**
* Create and refresh a new {@link ApplicationContext} based on the current state of
* this loader that this expected to fail. If the context does not fail, an
* {@link AssertionError} is thrown. If the exception does not match the specified
* {@code exceptionType}, an {@link AssertionError} is thrown as well. If the
* exception type matches, it is consumed by the specified {@link Consumer}.
* @param exceptionType the expected type of the failure
* @param consumer the consumer of the failure
* @param <E> the expected type of the failure
*/
@Override
public <E extends Throwable> void loadAndFail(Class<E> exceptionType,
Consumer<E> consumer) {
try (ApplicationContextLifecycleHandler handler = new ApplicationContextLifecycleHandler()) {
handler.load();
throw new AssertionError("ApplicationContext should have failed");
}
catch (Throwable ex) {
assertThat(ex).as("Wrong application context failure exception")
.isInstanceOf(exceptionType);
consumer.accept(exceptionType.cast(ex));
}
}
private T configureApplicationContext() {
T context = StandardContextLoader.this.contextSupplier.get();
if (this.classLoader != null) {
if (context instanceof DefaultResourceLoader) {
((DefaultResourceLoader) context).setClassLoader(this.classLoader);
}
else {
throw new IllegalStateException("Cannot configure ClassLoader: " + context
+ " is not a DefaultResourceLoader sub-class");
}
}
if (!ObjectUtils.isEmpty(this.env)) {
TestPropertyValues.of(this.env.toArray(new String[this.env.size()]))
.applyTo(context);
}
if (!ObjectUtils.isEmpty(this.userConfigurations)) {
context.register(this.userConfigurations
.toArray(new Class<?>[this.userConfigurations.size()]));
}
if (!ObjectUtils.isEmpty(this.autoConfigurations)) {
LinkedHashSet<Class<?>> linkedHashSet = new LinkedHashSet<>(
this.autoConfigurations);
context.register(
linkedHashSet.toArray(new Class<?>[this.autoConfigurations.size()]));
}
return context;
}
/**
* Handles the lifecycle of the {@link ApplicationContext}.
*/
private class ApplicationContextLifecycleHandler implements Closeable {
private final Map<String, String> customSystemProperties;
private final Map<String, String> previousSystemProperties = new HashMap<>();
private ConfigurableApplicationContext context;
ApplicationContextLifecycleHandler() {
this.customSystemProperties = new HashMap<>(
StandardContextLoader.this.systemProperties);
}
public T load() {
setCustomSystemProperties();
T context = configureApplicationContext();
context.refresh();
this.context = context;
return context;
}
@Override
public void close() {
try {
if (this.context != null) {
this.context.close();
}
}
finally {
unsetCustomSystemProperties();
}
}
private void setCustomSystemProperties() {
this.customSystemProperties.forEach((key, value) -> {
String previous = System.setProperty(key, value);
this.previousSystemProperties.put(key, previous);
});
}
private void unsetCustomSystemProperties() {
this.previousSystemProperties.forEach((key, value) -> {
if (value != null) {
System.setProperty(key, value);
}
else {
System.clearProperty(key);
}
});
}
}
}

101
spring-boot-test/src/test/java/org/springframework/boot/test/rule/ContextLoaderTests.java → spring-boot-test/src/test/java/org/springframework/boot/test/context/StandardContextLoaderTests.java
View File

@ -14,7 +14,7 @@
* limitations under the License.
*/
package org.springframework.boot.test.rule;
package org.springframework.boot.test.context;
import java.util.UUID;
@ -24,27 +24,28 @@ import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.springframework.beans.factory.BeanCreationException;
import org.springframework.boot.test.context.ContextLoader;
import org.springframework.boot.test.context.HidePackagesClassLoader;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.test.context.support.AbstractContextLoader;
import org.springframework.util.ClassUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
/**
* Tests for {@link ContextLoader}.
* Tests for {@link AbstractContextLoader}.
*
* @author Stephane Nicoll
*/
public class ContextLoaderTests {
public class StandardContextLoaderTests {
@Rule
public final ExpectedException thrown = ExpectedException.none();
private final ContextLoader contextLoader = new ContextLoader();
private final StandardContextLoader<AnnotationConfigApplicationContext> contextLoader = new StandardContextLoader<>(
() -> new AnnotationConfigApplicationContext());
@Test
public void systemPropertyIsSetAndRemoved() {
@ -61,9 +62,9 @@ public class ContextLoaderTests {
public void systemPropertyIsRemovedIfContextFailed() {
String key = "test." + UUID.randomUUID().toString();
assertThat(System.getProperties().containsKey(key)).isFalse();
this.contextLoader.systemProperty(key, "value")
.config(ConfigC.class).loadAndFail(e -> {
});
this.contextLoader.systemProperty(key, "value").config(ConfigC.class)
.loadAndFail(e -> {
});
assertThat(System.getProperties().containsKey(key)).isFalse();
}
@ -87,10 +88,10 @@ public class ContextLoaderTests {
public void systemPropertyCanBeSetToNullValue() {
String key = "test." + UUID.randomUUID().toString();
assertThat(System.getProperties().containsKey(key)).isFalse();
this.contextLoader.systemProperty(key, "value")
.systemProperty(key, null).load(context -> {
assertThat(System.getProperties().containsKey(key)).isFalse();
});
this.contextLoader.systemProperty(key, "value").systemProperty(key, null)
.load(context -> {
assertThat(System.getProperties().containsKey(key)).isFalse();
});
}
@Test
@ -102,8 +103,8 @@ public class ContextLoaderTests {
@Test
public void envIsAdditive() {
this.contextLoader.env("test.foo=1").env("test.bar=2").load(context -> {
ConfigurableEnvironment environment = context.getBean(
ConfigurableEnvironment.class);
ConfigurableEnvironment environment = context
.getBean(ConfigurableEnvironment.class);
assertThat(environment.getProperty("test.foo", Integer.class)).isEqualTo(1);
assertThat(environment.getProperty("test.bar", Integer.class)).isEqualTo(2);
});
@ -111,45 +112,42 @@ public class ContextLoaderTests {
@Test
public void envOverridesExistingKey() {
this.contextLoader.env("test.foo=1").env("test.foo=2").load(context ->
assertThat(context.getBean(ConfigurableEnvironment.class)
this.contextLoader.env("test.foo=1").env("test.foo=2")
.load(context -> assertThat(context.getBean(ConfigurableEnvironment.class)
.getProperty("test.foo", Integer.class)).isEqualTo(2));
}
@Test
public void configurationIsProcessedInOrder() {
this.contextLoader.config(ConfigA.class, AutoConfigA.class).load(context ->
assertThat(context.getBean("a")).isEqualTo("autoconfig-a"));
this.contextLoader.config(ConfigA.class, AutoConfigA.class).load(
context -> assertThat(context.getBean("a")).isEqualTo("autoconfig-a"));
}
@Test
public void configurationIsProcessedBeforeAutoConfiguration() {
this.contextLoader.autoConfig(AutoConfigA.class)
.config(ConfigA.class).load(context ->
assertThat(context.getBean("a")).isEqualTo("autoconfig-a"));
this.contextLoader.autoConfig(AutoConfigA.class).config(ConfigA.class).load(
context -> assertThat(context.getBean("a")).isEqualTo("autoconfig-a"));
}
@Test
public void configurationIsAdditive() {
this.contextLoader.config(AutoConfigA.class)
.config(AutoConfigB.class).load(context -> {
assertThat(context.containsBean("a")).isTrue();
assertThat(context.containsBean("b")).isTrue();
});
this.contextLoader.config(AutoConfigA.class).config(AutoConfigB.class)
.load(context -> {
assertThat(context.containsBean("a")).isTrue();
assertThat(context.containsBean("b")).isTrue();
});
}
@Test
public void autoConfigureFirstIsAppliedProperly() {
this.contextLoader.autoConfig(ConfigA.class)
.autoConfigFirst(AutoConfigA.class).load(context ->
assertThat(context.getBean("a")).isEqualTo("a"));
this.contextLoader.autoConfig(ConfigA.class).autoConfigFirst(AutoConfigA.class)
.load(context -> assertThat(context.getBean("a")).isEqualTo("a"));
}
@Test
public void autoConfigureFirstWithSeveralConfigsIsAppliedProperly() {
this.contextLoader.autoConfig(ConfigA.class, ConfigB.class)
.autoConfigFirst(AutoConfigA.class, AutoConfigB.class)
.load(context -> {
.autoConfigFirst(AutoConfigA.class, AutoConfigB.class).load(context -> {
assertThat(context.getBean("a")).isEqualTo("a");
assertThat(context.getBean("b")).isEqualTo(1);
});
@ -157,18 +155,18 @@ public class ContextLoaderTests {
@Test
public void autoConfigurationIsAdditive() {
this.contextLoader.autoConfig(AutoConfigA.class)
.autoConfig(AutoConfigB.class).load(context -> {
assertThat(context.containsBean("a")).isTrue();
assertThat(context.containsBean("b")).isTrue();
});
this.contextLoader.autoConfig(AutoConfigA.class).autoConfig(AutoConfigB.class)
.load(context -> {
assertThat(context.containsBean("a")).isTrue();
assertThat(context.containsBean("b")).isTrue();
});
}
@Test
public void loadAndFailWithExpectedException() {
this.contextLoader.config(ConfigC.class)
.loadAndFail(BeanCreationException.class, ex ->
assertThat(ex.getMessage()).contains("Error creating bean with name 'c'"));
this.contextLoader.config(ConfigC.class).loadAndFail(BeanCreationException.class,
ex -> assertThat(ex.getMessage())
.contains("Error creating bean with name 'c'"));
}
@Test
@ -182,16 +180,19 @@ public class ContextLoaderTests {
@Test
public void classLoaderIsUsed() {
this.contextLoader.classLoader(new HidePackagesClassLoader(
Gson.class.getPackage().getName())).load(context -> {
try {
ClassUtils.forName(Gson.class.getName(), context.getClassLoader());
fail("Should have thrown a ClassNotFoundException");
}
catch (ClassNotFoundException e) {
// expected
}
});
this.contextLoader
.classLoader(
new HidePackagesClassLoader(Gson.class.getPackage().getName()))
.load(context -> {
try {
ClassUtils.forName(Gson.class.getName(),
context.getClassLoader());
fail("Should have thrown a ClassNotFoundException");
}
catch (ClassNotFoundException e) {
// expected
}
});
}
@Configuration