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

Migrate tests to ApplicationContextRunner

This commit is contained in:
Stephane Nicoll 2017-09-11 15:36:27 +02:00
parent 85493367b6
commit b8eff0a0f6
5 changed files with 184 additions and 172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/session/AbstractSessionAutoConfigurationTests.java
View File

@ -16,16 +16,9 @@
package org.springframework.boot.autoconfigure.session;
import java.util.Collection;
import org.junit.After;
import org.springframework.beans.DirectFieldAccessor;
import org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration;
import org.springframework.boot.autoconfigure.web.ServerProperties;
import org.springframework.boot.test.util.TestPropertyValues;
import org.springframework.boot.test.context.assertj.AssertableWebApplicationContext;
import org.springframework.session.SessionRepository;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import static org.assertj.core.api.Assertions.assertThat;
@ -36,18 +29,11 @@ import static org.assertj.core.api.Assertions.assertThat;
*/
public abstract class AbstractSessionAutoConfigurationTests {
protected AnnotationConfigWebApplicationContext context;
@After
public void close() {
if (this.context != null) {
this.context.close();
}
}
protected <T extends SessionRepository<?>> T validateSessionRepository(
AssertableWebApplicationContext context,
Class<T> type) {
SessionRepository<?> repository = this.context.getBean(SessionRepository.class);
assertThat(context).hasSingleBean(SessionRepository.class);
SessionRepository<?> repository = context.getBean(SessionRepository.class);
assertThat(repository).as("Wrong session repository type").isInstanceOf(type);
return type.cast(repository);
}
@ -57,20 +43,4 @@ public abstract class AbstractSessionAutoConfigurationTests {
.getPropertyValue("defaultMaxInactiveInterval");
}
protected void load(String... environment) {
load(null, environment);
}
protected void load(Collection<Class<?>> configs, String... environment) {
AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
TestPropertyValues.of(environment).applyTo(ctx);
if (configs != null) {
ctx.register(configs.toArray(new Class<?>[configs.size()]));
}
ctx.register(ServerProperties.class, SessionAutoConfiguration.class,
PropertyPlaceholderAutoConfiguration.class);
ctx.refresh();
this.context = ctx;
}
}

54
spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/session/SessionAutoConfigurationHazelcastTests.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012-2016 the original author or authors.
* 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.
@ -16,13 +16,13 @@
package org.springframework.boot.autoconfigure.session;
import java.util.Collections;
import com.hazelcast.core.HazelcastInstance;
import com.hazelcast.core.IMap;
import org.junit.Test;
import org.springframework.beans.DirectFieldAccessor;
import org.springframework.boot.autoconfigure.AutoConfigurations;
import org.springframework.boot.test.context.runner.WebApplicationContextRunner;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.session.hazelcast.HazelcastFlushMode;
@ -42,37 +42,43 @@ import static org.mockito.Mockito.verify;
public class SessionAutoConfigurationHazelcastTests
extends AbstractSessionAutoConfigurationTests {
private final WebApplicationContextRunner contextRunner = new WebApplicationContextRunner()
.withConfiguration(AutoConfigurations.of(SessionAutoConfiguration.class))
.withUserConfiguration(HazelcastConfiguration.class);
@Test
public void defaultConfig() {
load(Collections.<Class<?>>singletonList(HazelcastConfiguration.class),
"spring.session.store-type=hazelcast");
validateSessionRepository(HazelcastSessionRepository.class);
HazelcastInstance hazelcastInstance = this.context
.getBean(HazelcastInstance.class);
verify(hazelcastInstance, times(1)).getMap("spring:session:sessions");
this.contextRunner.withPropertyValues("spring.session.store-type=hazelcast")
.run((context) -> {
validateSessionRepository(context, HazelcastSessionRepository.class);
HazelcastInstance hazelcastInstance = context
.getBean(HazelcastInstance.class);
verify(hazelcastInstance, times(1)).getMap("spring:session:sessions");
});
}
@Test
public void customMapName() {
load(Collections.<Class<?>>singletonList(HazelcastConfiguration.class),
"spring.session.store-type=hazelcast",
"spring.session.hazelcast.map-name=foo:bar:biz");
validateSessionRepository(HazelcastSessionRepository.class);
HazelcastInstance hazelcastInstance = this.context
.getBean(HazelcastInstance.class);
verify(hazelcastInstance, times(1)).getMap("foo:bar:biz");
this.contextRunner.withPropertyValues("spring.session.store-type=hazelcast",
"spring.session.hazelcast.map-name=foo:bar:biz").run((context) -> {
validateSessionRepository(context, HazelcastSessionRepository.class);
HazelcastInstance hazelcastInstance = context
.getBean(HazelcastInstance.class);
verify(hazelcastInstance, times(1)).getMap("foo:bar:biz");
});
}
@Test
public void customFlushMode() {
load(Collections.<Class<?>>singletonList(HazelcastConfiguration.class),
"spring.session.store-type=hazelcast",
"spring.session.hazelcast.flush-mode=immediate");
HazelcastSessionRepository repository = validateSessionRepository(
HazelcastSessionRepository.class);
assertThat(new DirectFieldAccessor(repository)
.getPropertyValue("hazelcastFlushMode"))
.isEqualTo(HazelcastFlushMode.IMMEDIATE);
this.contextRunner.withPropertyValues("spring.session.store-type=hazelcast",
"spring.session.hazelcast.flush-mode=immediate").run((context) -> {
HazelcastSessionRepository repository = validateSessionRepository(context,
HazelcastSessionRepository.class);
assertThat(new DirectFieldAccessor(repository)
.getPropertyValue("hazelcastFlushMode"))
.isEqualTo(HazelcastFlushMode.IMMEDIATE);
});
}
@Configuration

86
spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/session/SessionAutoConfigurationJdbcTests.java
View File

@ -16,17 +16,17 @@
package org.springframework.boot.autoconfigure.session;
import java.util.Arrays;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.springframework.beans.DirectFieldAccessor;
import org.springframework.boot.autoconfigure.AutoConfigurations;
import org.springframework.boot.autoconfigure.DatabaseInitializationMode;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration;
import org.springframework.boot.autoconfigure.jdbc.EmbeddedDataSourceConfiguration;
import org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration;
import org.springframework.boot.test.context.runner.WebApplicationContextRunner;
import org.springframework.jdbc.BadSqlGrammarException;
import org.springframework.jdbc.core.JdbcOperations;
import org.springframework.session.jdbc.JdbcOperationsSessionRepository;
@ -45,57 +45,61 @@ public class SessionAutoConfigurationJdbcTests
@Rule
public ExpectedException thrown = ExpectedException.none();
private final WebApplicationContextRunner contextRunner = new WebApplicationContextRunner()
.withConfiguration(AutoConfigurations.of(DataSourceAutoConfiguration.class,
DataSourceTransactionManagerAutoConfiguration.class,
SessionAutoConfiguration.class))
.withPropertyValues("spring.datasource.generate-unique-name=true");
@Test
public void defaultConfig() {
load(Arrays.asList(EmbeddedDataSourceConfiguration.class,
JdbcTemplateAutoConfiguration.class,
DataSourceTransactionManagerAutoConfiguration.class),
"spring.session.store-type=jdbc");
JdbcOperationsSessionRepository repository = validateSessionRepository(
JdbcOperationsSessionRepository.class);
assertThat(new DirectFieldAccessor(repository).getPropertyValue("tableName"))
.isEqualTo("SPRING_SESSION");
assertThat(
this.context.getBean(JdbcSessionProperties.class).getInitializeSchema())
.isEqualTo(DatabaseInitializationMode.EMBEDDED);
assertThat(this.context.getBean(JdbcOperations.class)
.queryForList("select * from SPRING_SESSION")).isEmpty();
this.contextRunner.withConfiguration(AutoConfigurations.of(
JdbcTemplateAutoConfiguration.class))
.withPropertyValues("spring.session.store-type=jdbc").run((context) -> {
JdbcOperationsSessionRepository repository = validateSessionRepository(context,
JdbcOperationsSessionRepository.class);
assertThat(new DirectFieldAccessor(repository).getPropertyValue("tableName"))
.isEqualTo("SPRING_SESSION");
assertThat(context.getBean(JdbcSessionProperties.class).getInitializeSchema())
.isEqualTo(DatabaseInitializationMode.EMBEDDED);
assertThat(context.getBean(JdbcOperations.class)
.queryForList("select * from SPRING_SESSION")).isEmpty();
});
}
@Test
public void disableDatabaseInitializer() {
load(Arrays.asList(EmbeddedDataSourceConfiguration.class,
DataSourceTransactionManagerAutoConfiguration.class),
this.contextRunner.withPropertyValues(
"spring.session.store-type=jdbc",
"spring.session.jdbc.initialize-schema=never");
JdbcOperationsSessionRepository repository = validateSessionRepository(
JdbcOperationsSessionRepository.class);
assertThat(new DirectFieldAccessor(repository).getPropertyValue("tableName"))
.isEqualTo("SPRING_SESSION");
assertThat(
this.context.getBean(JdbcSessionProperties.class).getInitializeSchema())
.isEqualTo(DatabaseInitializationMode.NEVER);
this.thrown.expect(BadSqlGrammarException.class);
this.context.getBean(JdbcOperations.class)
.queryForList("select * from SPRING_SESSION");
"spring.session.jdbc.initialize-schema=never").run((context) -> {
JdbcOperationsSessionRepository repository = validateSessionRepository(context,
JdbcOperationsSessionRepository.class);
assertThat(new DirectFieldAccessor(repository).getPropertyValue("tableName"))
.isEqualTo("SPRING_SESSION");
assertThat(context.getBean(JdbcSessionProperties.class).getInitializeSchema())
.isEqualTo(DatabaseInitializationMode.NEVER);
this.thrown.expect(BadSqlGrammarException.class);
context.getBean(JdbcOperations.class).queryForList(
"select * from SPRING_SESSION");
});
}
@Test
public void customTableName() {
load(Arrays.asList(EmbeddedDataSourceConfiguration.class,
DataSourceTransactionManagerAutoConfiguration.class),
this.contextRunner.withPropertyValues(
"spring.session.store-type=jdbc",
"spring.session.jdbc.table-name=FOO_BAR",
"spring.session.jdbc.schema=classpath:session/custom-schema-h2.sql");
JdbcOperationsSessionRepository repository = validateSessionRepository(
JdbcOperationsSessionRepository.class);
assertThat(new DirectFieldAccessor(repository).getPropertyValue("tableName"))
.isEqualTo("FOO_BAR");
assertThat(
this.context.getBean(JdbcSessionProperties.class).getInitializeSchema())
.isEqualTo(DatabaseInitializationMode.EMBEDDED);
assertThat(this.context.getBean(JdbcOperations.class)
.queryForList("select * from FOO_BAR")).isEmpty();
"spring.session.jdbc.schema=classpath:session/custom-schema-h2.sql")
.run((context) -> {
JdbcOperationsSessionRepository repository = validateSessionRepository(context,
JdbcOperationsSessionRepository.class);
assertThat(new DirectFieldAccessor(repository).getPropertyValue("tableName"))
.isEqualTo("FOO_BAR");
assertThat(context.getBean(JdbcSessionProperties.class).getInitializeSchema())
.isEqualTo(DatabaseInitializationMode.EMBEDDED);
assertThat(context.getBean(JdbcOperations.class)
.queryForList("select * from FOO_BAR")).isEmpty();
});
}
}

53
spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/session/SessionAutoConfigurationRedisTests.java
View File

@ -16,13 +16,15 @@
package org.springframework.boot.autoconfigure.session;
import java.util.Collections;
import org.junit.Rule;
import org.junit.Test;
import org.springframework.beans.DirectFieldAccessor;
import org.springframework.boot.autoconfigure.AutoConfigurations;
import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
import org.springframework.boot.test.context.assertj.AssertableWebApplicationContext;
import org.springframework.boot.test.context.runner.ContextConsumer;
import org.springframework.boot.test.context.runner.WebApplicationContextRunner;
import org.springframework.boot.testsupport.rule.RedisTestServer;
import org.springframework.session.data.redis.RedisFlushMode;
import org.springframework.session.data.redis.RedisOperationsSessionRepository;
@ -40,33 +42,38 @@ public class SessionAutoConfigurationRedisTests
@Rule
public final RedisTestServer redis = new RedisTestServer();
protected final WebApplicationContextRunner contextRunner = new WebApplicationContextRunner()
.withConfiguration(AutoConfigurations.of(SessionAutoConfiguration.class));
@Test
public void redisSessionStore() {
load(Collections.<Class<?>>singletonList(RedisAutoConfiguration.class),
"spring.session.store-type=redis");
validateSpringSessionUsesRedis();
}
private void validateSpringSessionUsesRedis() {
RedisOperationsSessionRepository repository = validateSessionRepository(
RedisOperationsSessionRepository.class);
assertThat(repository.getSessionCreatedChannelPrefix())
.isEqualTo("spring:session:event:created:");
assertThat(new DirectFieldAccessor(repository).getPropertyValue("redisFlushMode"))
.isEqualTo(RedisFlushMode.ON_SAVE);
this.contextRunner.withConfiguration(AutoConfigurations.of(RedisAutoConfiguration.class))
.withPropertyValues("spring.session.store-type=redis")
.run(validateSpringSessionUsesRedis("spring:session:event:created:",
RedisFlushMode.ON_SAVE));
}
@Test
public void redisSessionStoreWithCustomizations() {
load(Collections.<Class<?>>singletonList(RedisAutoConfiguration.class),
"spring.session.store-type=redis", "spring.session.redis.namespace=foo",
"spring.session.redis.flush-mode=immediate");
RedisOperationsSessionRepository repository = validateSessionRepository(
RedisOperationsSessionRepository.class);
assertThat(repository.getSessionCreatedChannelPrefix())
.isEqualTo("spring:session:foo:event:created:");
assertThat(new DirectFieldAccessor(repository).getPropertyValue("redisFlushMode"))
.isEqualTo(RedisFlushMode.IMMEDIATE);
this.contextRunner.withConfiguration(AutoConfigurations.of(RedisAutoConfiguration.class))
.withPropertyValues("spring.session.store-type=redis",
"spring.session.redis.namespace=foo",
"spring.session.redis.flush-mode=immediate")
.run(validateSpringSessionUsesRedis("spring:session:foo:event:created:",
RedisFlushMode.IMMEDIATE));
}
private ContextConsumer<AssertableWebApplicationContext> validateSpringSessionUsesRedis(
String sessionCreatedChannelPrefix, RedisFlushMode flushMode) {
return context -> {
RedisOperationsSessionRepository repository = validateSessionRepository(context,
RedisOperationsSessionRepository.class);
assertThat(repository.getSessionCreatedChannelPrefix())
.isEqualTo(sessionCreatedChannelPrefix);
assertThat(new DirectFieldAccessor(repository).getPropertyValue("redisFlushMode"))
.isEqualTo(flushMode);
};
}
}

125
spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/session/SessionAutoConfigurationTests.java
View File

@ -21,11 +21,12 @@ import java.util.EnumSet;
import javax.servlet.DispatcherType;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.springframework.beans.factory.BeanCreationException;
import org.springframework.boot.autoconfigure.AutoConfigurations;
import org.springframework.boot.autoconfigure.web.ServerProperties;
import org.springframework.boot.test.context.runner.WebApplicationContextRunner;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@ -46,95 +47,119 @@ import static org.assertj.core.api.Assertions.assertThat;
*/
public class SessionAutoConfigurationTests extends AbstractSessionAutoConfigurationTests {
@Rule
public ExpectedException thrown = ExpectedException.none();
private final WebApplicationContextRunner contextRunner = new WebApplicationContextRunner()
.withConfiguration(AutoConfigurations.of(SessionAutoConfiguration.class));
@Test
public void contextFailsIfStoreTypeNotSet() {
this.thrown.expect(BeanCreationException.class);
this.thrown.expectMessage("No Spring Session store is configured");
this.thrown.expectMessage("set the 'spring.session.store-type' property");
load();
this.contextRunner.run((context) -> {
assertThat(context).hasFailed();
assertThat(context).getFailure().hasMessageContaining(
"No Spring Session store is configured");
assertThat(context).getFailure().hasMessageContaining(
"set the 'spring.session.store-type' property");
});
}
@Test
public void contextFailsIfStoreTypeNotAvailable() {
this.thrown.expect(BeanCreationException.class);
this.thrown.expectMessage("No session repository could be auto-configured");
this.thrown.expectMessage("session store type is 'jdbc'");
load("spring.session.store-type=jdbc");
this.contextRunner.withPropertyValues("spring.session.store-type=jdbc")
.run((context) -> {
assertThat(context).hasFailed();
assertThat(context).getFailure().isInstanceOf(BeanCreationException.class);
assertThat(context).getFailure().hasMessageContaining(
"No session repository could be auto-configured");
assertThat(context).getFailure().hasMessageContaining(
"session store type is 'jdbc'");
});
}
@Test
public void autoConfigurationDisabledIfStoreTypeSetToNone() {
load("spring.session.store-type=none");
assertThat(this.context.getBeansOfType(SessionRepository.class)).hasSize(0);
this.contextRunner.withPropertyValues("spring.session.store-type=none")
.run((context) -> assertThat(context)
.doesNotHaveBean(SessionRepository.class));
}
@Test
public void backOffIfSessionRepositoryIsPresent() {
load(Collections.singletonList(SessionRepositoryConfiguration.class),
"spring.session.store-type=redis");
MapSessionRepository repository = validateSessionRepository(
MapSessionRepository.class);
assertThat(this.context.getBean("mySessionRepository")).isSameAs(repository);
this.contextRunner.withUserConfiguration(SessionRepositoryConfiguration.class)
.withPropertyValues("spring.session.store-type=redis").run((context) -> {
MapSessionRepository repository = validateSessionRepository(context,
MapSessionRepository.class);
assertThat(context).getBean("mySessionRepository").isSameAs(repository);
});
}
@Test
public void hashMapSessionStore() {
load("spring.session.store-type=hash-map");
MapSessionRepository repository = validateSessionRepository(
MapSessionRepository.class);
assertThat(getSessionTimeout(repository)).isNull();
this.contextRunner
.withPropertyValues("spring.session.store-type=hash-map")
.run((context) -> {
MapSessionRepository repository = validateSessionRepository(context,
MapSessionRepository.class);
assertThat(getSessionTimeout(repository)).isNull();
});
}
@Test
public void hashMapSessionStoreCustomTimeout() {
load("spring.session.store-type=hash-map", "server.session.timeout=3000");
MapSessionRepository repository = validateSessionRepository(
MapSessionRepository.class);
assertThat(getSessionTimeout(repository)).isEqualTo(3000);
this.contextRunner.withUserConfiguration(ServerProperties.class).
withPropertyValues("spring.session.store-type=hash-map",
"server.session.timeout=3000").run((context) -> {
MapSessionRepository repository = validateSessionRepository(context,
MapSessionRepository.class);
assertThat(getSessionTimeout(repository)).isEqualTo(3000);
});
}
@Test
public void springSessionTimeoutIsNotAValidProperty() {
this.thrown.expect(BeanCreationException.class);
this.thrown.expectMessage("Could not bind");
load("spring.session.store-type=hash-map", "spring.session.timeout=3000");
this.contextRunner.withPropertyValues("spring.session.store-type=hash-map",
"spring.session.timeout=3000").run((context) -> {
assertThat(context).hasFailed();
assertThat(context).getFailure().isInstanceOf(BeanCreationException.class);
assertThat(context).getFailure().hasMessageContaining("Could not bind");
});
}
@SuppressWarnings("unchecked")
@Test
public void filterIsRegisteredWithAsyncErrorAndRequestDispatcherTypes() {
load("spring.session.store-type=hash-map");
FilterRegistrationBean<?> registration = this.context
.getBean(FilterRegistrationBean.class);
assertThat(registration.getFilter())
.isSameAs(this.context.getBean(SessionRepositoryFilter.class));
assertThat((EnumSet<DispatcherType>) ReflectionTestUtils.getField(registration,
"dispatcherTypes")).containsOnly(DispatcherType.ASYNC,
DispatcherType.ERROR, DispatcherType.REQUEST);
this.contextRunner.withPropertyValues(
"spring.session.store-type=hash-map").run((context) -> {
FilterRegistrationBean<?> registration = context
.getBean(FilterRegistrationBean.class);
assertThat(registration.getFilter())
.isSameAs(context.getBean(SessionRepositoryFilter.class));
assertThat((EnumSet<DispatcherType>) ReflectionTestUtils.getField(registration,
"dispatcherTypes")).containsOnly(DispatcherType.ASYNC,
DispatcherType.ERROR, DispatcherType.REQUEST);
});
}
@Test
public void filterOrderCanBeCustomized() {
load("spring.session.store-type=hash-map",
"spring.session.servlet.filter-order=123");
FilterRegistrationBean<?> registration = this.context
.getBean(FilterRegistrationBean.class);
assertThat(registration.getOrder()).isEqualTo(123);
this.contextRunner.withPropertyValues("spring.session.store-type=hash-map",
"spring.session.servlet.filter-order=123").run((context) -> {
FilterRegistrationBean<?> registration = context
.getBean(FilterRegistrationBean.class);
assertThat(registration.getOrder()).isEqualTo(123);
});
}
@SuppressWarnings("unchecked")
@Test
public void filterDispatcherTypesCanBeCustomized() {
load("spring.session.store-type=hash-map",
"spring.session.servlet.filter-dispatcher-types=error, request");
FilterRegistrationBean<?> registration = this.context
.getBean(FilterRegistrationBean.class);
assertThat((EnumSet<DispatcherType>) ReflectionTestUtils.getField(registration,
"dispatcherTypes")).containsOnly(DispatcherType.ERROR,
DispatcherType.REQUEST);
this.contextRunner.withPropertyValues("spring.session.store-type=hash-map",
"spring.session.servlet.filter-dispatcher-types=error, request")
.run((context) -> {
FilterRegistrationBean<?> registration = context
.getBean(FilterRegistrationBean.class);
assertThat((EnumSet<DispatcherType>) ReflectionTestUtils.getField(registration,
"dispatcherTypes")).containsOnly(DispatcherType.ERROR,
DispatcherType.REQUEST);
});
}
@Configuration