Migrate tests to ApplicationContextRunner

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

@@ -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;
-	}
-
 }

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

 /*
- * 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

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

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

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

@@ -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);
+		};
 	}
 
 }

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

@@ -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