Polish

spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/orm/jpa/JpaPropertiesTests.java

@@ -20,20 +20,21 @@ import java.sql.Connection;
 import java.sql.DatabaseMetaData;
 import java.sql.SQLException;
 import java.util.Map;
+import java.util.function.Consumer;
 
 import javax.sql.DataSource;
 
 import org.hibernate.boot.model.naming.ImplicitNamingStrategy;
 import org.hibernate.boot.model.naming.PhysicalNamingStrategy;
 import org.hibernate.cfg.AvailableSettings;
-import org.junit.After;
 import org.junit.Test;
 
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.boot.orm.jpa.hibernate.SpringImplicitNamingStrategy;
 import org.springframework.boot.orm.jpa.hibernate.SpringPhysicalNamingStrategy;
-import org.springframework.boot.test.util.TestPropertyValues;
-import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+import org.springframework.boot.test.context.assertj.AssertableApplicationContext;
+import org.springframework.boot.test.context.runner.ApplicationContextRunner;
+import org.springframework.boot.test.context.runner.ContextConsumer;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.orm.jpa.vendor.Database;
 
@@ -51,18 +52,12 @@ import static org.mockito.Mockito.verify;
  */
 public class JpaPropertiesTests {
 
-	private AnnotationConfigApplicationContext context;
-
-	@After
-	public void close() {
-		if (this.context != null) {
-			this.context.close();
-		}
-	}
+	private final ApplicationContextRunner contextRunner = new ApplicationContextRunner()
+			.withUserConfiguration(TestConfiguration.class);
 
 	@Test
 	public void noCustomNamingStrategy() {
-		JpaProperties properties = load();
+		this.contextRunner.run(assertJpaProperties((properties) -> {
 			Map<String, Object> hibernateProperties = properties
 					.getHibernateProperties(new HibernateSettings().ddlAuto("none"));
 			assertThat(hibernateProperties)
@@ -73,13 +68,16 @@ public class JpaPropertiesTests {
 			assertThat(hibernateProperties).containsEntry(
 					"hibernate.implicit_naming_strategy",
 					SpringImplicitNamingStrategy.class.getName());
+		}));
 	}
 
 	@Test
 	public void hibernate5CustomNamingStrategies() {
-		JpaProperties properties = load(
+		this.contextRunner
+				.withPropertyValues(
 						"spring.jpa.hibernate.naming.implicit-strategy:com.example.Implicit",
-				"spring.jpa.hibernate.naming.physical-strategy:com.example.Physical");
+						"spring.jpa.hibernate.naming.physical-strategy:com.example.Physical"
+				).run(assertJpaProperties((properties) -> {
 			Map<String, Object> hibernateProperties = properties
 					.getHibernateProperties(new HibernateSettings().ddlAuto("none"));
 			assertThat(hibernateProperties).contains(
@@ -87,11 +85,12 @@ public class JpaPropertiesTests {
 					entry("hibernate.physical_naming_strategy", "com.example.Physical"));
 			assertThat(hibernateProperties)
 					.doesNotContainKeys("hibernate.ejb.naming_strategy");
+		}));
 	}
 
 	@Test
 	public void namingStrategyInstancesCanBeUsed() {
-		JpaProperties properties = load();
+		this.contextRunner.run(assertJpaProperties((properties) -> {
 			ImplicitNamingStrategy implicitStrategy = mock(ImplicitNamingStrategy.class);
 			PhysicalNamingStrategy physicalStrategy = mock(PhysicalNamingStrategy.class);
 			Map<String, Object> hibernateProperties = properties
@@ -103,13 +102,16 @@ public class JpaPropertiesTests {
 					entry("hibernate.physical_naming_strategy", physicalStrategy));
 			assertThat(hibernateProperties)
 					.doesNotContainKeys("hibernate.ejb.naming_strategy");
+		}));
 	}
 
 	@Test
 	public void namingStrategyInstancesTakePrecedenceOverNamingStrategyProperties() {
-		JpaProperties properties = load(
+		this.contextRunner
+				.withPropertyValues(
 						"spring.jpa.hibernate.naming.implicit-strategy:com.example.Implicit",
-				"spring.jpa.hibernate.naming.physical-strategy:com.example.Physical");
+						"spring.jpa.hibernate.naming.physical-strategy:com.example.Physical"
+				).run(assertJpaProperties((properties) -> {
 			ImplicitNamingStrategy implicitStrategy = mock(ImplicitNamingStrategy.class);
 			PhysicalNamingStrategy physicalStrategy = mock(PhysicalNamingStrategy.class);
 			Map<String, Object> hibernateProperties = properties
@@ -121,13 +123,16 @@ public class JpaPropertiesTests {
 					entry("hibernate.physical_naming_strategy", physicalStrategy));
 			assertThat(hibernateProperties)
 					.doesNotContainKeys("hibernate.ejb.naming_strategy");
+		}));
 	}
 
 	@Test
 	public void hibernate5CustomNamingStrategiesViaJpaProperties() {
-		JpaProperties properties = load(
+		this.contextRunner
+				.withPropertyValues(
 						"spring.jpa.properties.hibernate.implicit_naming_strategy:com.example.Implicit",
-				"spring.jpa.properties.hibernate.physical_naming_strategy:com.example.Physical");
+						"spring.jpa.properties.hibernate.physical_naming_strategy:com.example.Physical"
+				).run(assertJpaProperties((properties) -> {
 			Map<String, Object> hibernateProperties = properties
 					.getHibernateProperties(new HibernateSettings().ddlAuto("none"));
 			// You can override them as we don't provide any default
@@ -136,65 +141,88 @@ public class JpaPropertiesTests {
 					entry("hibernate.physical_naming_strategy", "com.example.Physical"));
 			assertThat(hibernateProperties)
 					.doesNotContainKeys("hibernate.ejb.naming_strategy");
+		}));
 	}
 
 	@Test
 	public void useNewIdGeneratorMappingsDefault() {
-		JpaProperties properties = load();
+		this.contextRunner.run(assertJpaProperties((properties) -> {
 			Map<String, Object> hibernateProperties = properties
 					.getHibernateProperties(new HibernateSettings().ddlAuto("none"));
 			assertThat(hibernateProperties)
 					.containsEntry(AvailableSettings.USE_NEW_ID_GENERATOR_MAPPINGS, "true");
+		}));
 	}
 
 	@Test
 	public void useNewIdGeneratorMappingsFalse() {
-		JpaProperties properties = load(
-				"spring.jpa.hibernate.use-new-id-generator-mappings:false");
+		this.contextRunner
+				.withPropertyValues(
+						"spring.jpa.hibernate.use-new-id-generator-mappings:false"
+				).run(assertJpaProperties((properties) -> {
 			Map<String, Object> hibernateProperties = properties
 					.getHibernateProperties(new HibernateSettings().ddlAuto("none"));
 			assertThat(hibernateProperties)
 					.containsEntry(AvailableSettings.USE_NEW_ID_GENERATOR_MAPPINGS, "false");
+		}));
 	}
 
 	@Test
-	public void determineDatabaseNoCheckIfDatabaseIsSet() throws SQLException {
-		JpaProperties properties = load("spring.jpa.database=postgresql");
+	public void determineDatabaseNoCheckIfDatabaseIsSet() {
+		this.contextRunner
+				.withPropertyValues("spring.jpa.database=postgresql")
+				.run(assertJpaProperties((properties) -> {
 					DataSource dataSource = mockStandaloneDataSource();
 					Database database = properties.determineDatabase(dataSource);
 					assertThat(database).isEqualTo(Database.POSTGRESQL);
+					try {
 						verify(dataSource, never()).getConnection();
 					}
+					catch (SQLException ex) {
+						throw new IllegalStateException("Should not happen", ex);
+					}
+				}));
+	}
 
 	@Test
 	public void determineDatabaseWithKnownUrl() {
-		JpaProperties properties = load();
+		this.contextRunner.run(assertJpaProperties((properties) -> {
 			Database database = properties
 					.determineDatabase(mockDataSource("jdbc:h2:mem:testdb"));
 			assertThat(database).isEqualTo(Database.H2);
+		}));
 	}
 
 	@Test
 	public void determineDatabaseWithKnownUrlAndUserConfig() {
-		JpaProperties properties = load("spring.jpa.database=mysql");
+		this.contextRunner
+				.withPropertyValues("spring.jpa.database=mysql")
+				.run(assertJpaProperties((properties) -> {
 					Database database = properties
 							.determineDatabase(mockDataSource("jdbc:h2:mem:testdb"));
 					assertThat(database).isEqualTo(Database.MYSQL);
+				}));
 	}
 
 	@Test
 	public void determineDatabaseWithUnknownUrl() {
-		JpaProperties properties = load();
+		this.contextRunner.run(assertJpaProperties((properties) -> {
 			Database database = properties
 					.determineDatabase(mockDataSource("jdbc:unknown://localhost"));
 			assertThat(database).isEqualTo(Database.DEFAULT);
+		}));
 	}
 
-	private DataSource mockStandaloneDataSource() throws SQLException {
+	private DataSource mockStandaloneDataSource() {
+		try {
 			DataSource ds = mock(DataSource.class);
 			given(ds.getConnection()).willThrow(SQLException.class);
 			return ds;
 		}
+		catch (SQLException ex) {
+			throw new IllegalStateException("Should not happen", ex);
+		}
+	}
 
 	private DataSource mockDataSource(String jdbcUrl) {
 		DataSource ds = mock(DataSource.class);
@@ -211,13 +239,12 @@ public class JpaPropertiesTests {
 		return ds;
 	}
 
-	private JpaProperties load(String... environment) {
-		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
-		TestPropertyValues.of(environment).applyTo(ctx);
-		ctx.register(TestConfiguration.class);
-		ctx.refresh();
-		this.context = ctx;
-		return this.context.getBean(JpaProperties.class);
+	private ContextConsumer<AssertableApplicationContext> assertJpaProperties(
+			Consumer<JpaProperties> consumer) {
+		return (context) -> {
+			assertThat(context).hasSingleBean(JpaProperties.class);
+			consumer.accept(context.getBean(JpaProperties.class));
+		};
 	}
 
 	@Configuration