GitHub-Spring
/
spring-boot
mirror of https://github.com/spring-projects/spring-boot.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Migrate tests to ApplicationContextRunner

pull/10256/head
Stephane Nicoll 9 years ago
parent
85493367b6
commit
b8eff0a0f6
5 changed files with 184 additions and 172 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 38
      spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/session/AbstractSessionAutoConfigurationTests.java
  2. 54
      spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/session/SessionAutoConfigurationHazelcastTests.java
  3. 86
      spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/session/SessionAutoConfigurationJdbcTests.java
  4. 53
      spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/session/SessionAutoConfigurationRedisTests.java
  5. 125
      spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/session/SessionAutoConfigurationTests.java

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

@ -16,16 +16,9 @@ @@ -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; @@ -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 { @@ -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
Unescape View File

@ -1,5 +1,5 @@ @@ -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 @@ @@ -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; @@ -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
Unescape View File

@ -16,17 +16,17 @@ @@ -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 @@ -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
Unescape View File

@ -16,13 +16,15 @@ @@ -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 @@ -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
Unescape View File

@ -21,11 +21,12 @@ import java.util.EnumSet; @@ -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; @@ -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

Write Preview
Loading…
Cancel
Save