From 641013787d7d89148decd904360e9b5f98ad2a7f Mon Sep 17 00:00:00 2001 From: Stephane Nicoll Date: Fri, 5 Jan 2018 11:40:26 +0100 Subject: [PATCH] Polish --- .../orm/jpa/JpaPropertiesTests.java | 245 ++++++++++-------- 1 file changed, 136 insertions(+), 109 deletions(-) diff --git a/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/orm/jpa/JpaPropertiesTests.java b/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/orm/jpa/JpaPropertiesTests.java index 50753afbec..dc115f840a 100644 --- a/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/orm/jpa/JpaPropertiesTests.java +++ b/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,149 +52,176 @@ 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(); - Map hibernateProperties = properties - .getHibernateProperties(new HibernateSettings().ddlAuto("none")); - assertThat(hibernateProperties) - .doesNotContainKeys("hibernate.ejb.naming_strategy"); - assertThat(hibernateProperties).containsEntry( - "hibernate.physical_naming_strategy", - SpringPhysicalNamingStrategy.class.getName()); - assertThat(hibernateProperties).containsEntry( - "hibernate.implicit_naming_strategy", - SpringImplicitNamingStrategy.class.getName()); + this.contextRunner.run(assertJpaProperties((properties) -> { + Map hibernateProperties = properties + .getHibernateProperties(new HibernateSettings().ddlAuto("none")); + assertThat(hibernateProperties) + .doesNotContainKeys("hibernate.ejb.naming_strategy"); + assertThat(hibernateProperties).containsEntry( + "hibernate.physical_naming_strategy", + SpringPhysicalNamingStrategy.class.getName()); + assertThat(hibernateProperties).containsEntry( + "hibernate.implicit_naming_strategy", + SpringImplicitNamingStrategy.class.getName()); + })); } @Test public void hibernate5CustomNamingStrategies() { - JpaProperties properties = load( - "spring.jpa.hibernate.naming.implicit-strategy:com.example.Implicit", - "spring.jpa.hibernate.naming.physical-strategy:com.example.Physical"); - Map hibernateProperties = properties - .getHibernateProperties(new HibernateSettings().ddlAuto("none")); - assertThat(hibernateProperties).contains( - entry("hibernate.implicit_naming_strategy", "com.example.Implicit"), - entry("hibernate.physical_naming_strategy", "com.example.Physical")); - assertThat(hibernateProperties) - .doesNotContainKeys("hibernate.ejb.naming_strategy"); + this.contextRunner + .withPropertyValues( + "spring.jpa.hibernate.naming.implicit-strategy:com.example.Implicit", + "spring.jpa.hibernate.naming.physical-strategy:com.example.Physical" + ).run(assertJpaProperties((properties) -> { + Map hibernateProperties = properties + .getHibernateProperties(new HibernateSettings().ddlAuto("none")); + assertThat(hibernateProperties).contains( + entry("hibernate.implicit_naming_strategy", "com.example.Implicit"), + entry("hibernate.physical_naming_strategy", "com.example.Physical")); + assertThat(hibernateProperties) + .doesNotContainKeys("hibernate.ejb.naming_strategy"); + })); } @Test public void namingStrategyInstancesCanBeUsed() { - JpaProperties properties = load(); - ImplicitNamingStrategy implicitStrategy = mock(ImplicitNamingStrategy.class); - PhysicalNamingStrategy physicalStrategy = mock(PhysicalNamingStrategy.class); - Map hibernateProperties = properties - .getHibernateProperties(new HibernateSettings().ddlAuto("none") - .implicitNamingStrategy(implicitStrategy) - .physicalNamingStrategy(physicalStrategy)); - assertThat(hibernateProperties).contains( - entry("hibernate.implicit_naming_strategy", implicitStrategy), - entry("hibernate.physical_naming_strategy", physicalStrategy)); - assertThat(hibernateProperties) - .doesNotContainKeys("hibernate.ejb.naming_strategy"); + this.contextRunner.run(assertJpaProperties((properties) -> { + ImplicitNamingStrategy implicitStrategy = mock(ImplicitNamingStrategy.class); + PhysicalNamingStrategy physicalStrategy = mock(PhysicalNamingStrategy.class); + Map hibernateProperties = properties + .getHibernateProperties(new HibernateSettings().ddlAuto("none") + .implicitNamingStrategy(implicitStrategy) + .physicalNamingStrategy(physicalStrategy)); + assertThat(hibernateProperties).contains( + entry("hibernate.implicit_naming_strategy", implicitStrategy), + entry("hibernate.physical_naming_strategy", physicalStrategy)); + assertThat(hibernateProperties) + .doesNotContainKeys("hibernate.ejb.naming_strategy"); + })); } @Test public void namingStrategyInstancesTakePrecedenceOverNamingStrategyProperties() { - JpaProperties properties = load( - "spring.jpa.hibernate.naming.implicit-strategy:com.example.Implicit", - "spring.jpa.hibernate.naming.physical-strategy:com.example.Physical"); - ImplicitNamingStrategy implicitStrategy = mock(ImplicitNamingStrategy.class); - PhysicalNamingStrategy physicalStrategy = mock(PhysicalNamingStrategy.class); - Map hibernateProperties = properties - .getHibernateProperties(new HibernateSettings().ddlAuto("none") - .implicitNamingStrategy(implicitStrategy) - .physicalNamingStrategy(physicalStrategy)); - assertThat(hibernateProperties).contains( - entry("hibernate.implicit_naming_strategy", implicitStrategy), - entry("hibernate.physical_naming_strategy", physicalStrategy)); - assertThat(hibernateProperties) - .doesNotContainKeys("hibernate.ejb.naming_strategy"); + this.contextRunner + .withPropertyValues( + "spring.jpa.hibernate.naming.implicit-strategy:com.example.Implicit", + "spring.jpa.hibernate.naming.physical-strategy:com.example.Physical" + ).run(assertJpaProperties((properties) -> { + ImplicitNamingStrategy implicitStrategy = mock(ImplicitNamingStrategy.class); + PhysicalNamingStrategy physicalStrategy = mock(PhysicalNamingStrategy.class); + Map hibernateProperties = properties + .getHibernateProperties(new HibernateSettings().ddlAuto("none") + .implicitNamingStrategy(implicitStrategy) + .physicalNamingStrategy(physicalStrategy)); + assertThat(hibernateProperties).contains( + entry("hibernate.implicit_naming_strategy", implicitStrategy), + entry("hibernate.physical_naming_strategy", physicalStrategy)); + assertThat(hibernateProperties) + .doesNotContainKeys("hibernate.ejb.naming_strategy"); + })); } @Test public void hibernate5CustomNamingStrategiesViaJpaProperties() { - JpaProperties properties = load( - "spring.jpa.properties.hibernate.implicit_naming_strategy:com.example.Implicit", - "spring.jpa.properties.hibernate.physical_naming_strategy:com.example.Physical"); - Map hibernateProperties = properties - .getHibernateProperties(new HibernateSettings().ddlAuto("none")); - // You can override them as we don't provide any default - assertThat(hibernateProperties).contains( - entry("hibernate.implicit_naming_strategy", "com.example.Implicit"), - entry("hibernate.physical_naming_strategy", "com.example.Physical")); - assertThat(hibernateProperties) - .doesNotContainKeys("hibernate.ejb.naming_strategy"); + this.contextRunner + .withPropertyValues( + "spring.jpa.properties.hibernate.implicit_naming_strategy:com.example.Implicit", + "spring.jpa.properties.hibernate.physical_naming_strategy:com.example.Physical" + ).run(assertJpaProperties((properties) -> { + Map hibernateProperties = properties + .getHibernateProperties(new HibernateSettings().ddlAuto("none")); + // You can override them as we don't provide any default + assertThat(hibernateProperties).contains( + entry("hibernate.implicit_naming_strategy", "com.example.Implicit"), + entry("hibernate.physical_naming_strategy", "com.example.Physical")); + assertThat(hibernateProperties) + .doesNotContainKeys("hibernate.ejb.naming_strategy"); + })); } @Test public void useNewIdGeneratorMappingsDefault() { - JpaProperties properties = load(); - Map hibernateProperties = properties - .getHibernateProperties(new HibernateSettings().ddlAuto("none")); - assertThat(hibernateProperties) - .containsEntry(AvailableSettings.USE_NEW_ID_GENERATOR_MAPPINGS, "true"); + this.contextRunner.run(assertJpaProperties((properties) -> { + Map 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"); - Map hibernateProperties = properties - .getHibernateProperties(new HibernateSettings().ddlAuto("none")); - assertThat(hibernateProperties) - .containsEntry(AvailableSettings.USE_NEW_ID_GENERATOR_MAPPINGS, "false"); + this.contextRunner + .withPropertyValues( + "spring.jpa.hibernate.use-new-id-generator-mappings:false" + ).run(assertJpaProperties((properties) -> { + Map 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"); - DataSource dataSource = mockStandaloneDataSource(); - Database database = properties.determineDatabase(dataSource); - assertThat(database).isEqualTo(Database.POSTGRESQL); - verify(dataSource, never()).getConnection(); + 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(); - Database database = properties - .determineDatabase(mockDataSource("jdbc:h2:mem:testdb")); - assertThat(database).isEqualTo(Database.H2); + 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"); - Database database = properties - .determineDatabase(mockDataSource("jdbc:h2:mem:testdb")); - assertThat(database).isEqualTo(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(); - Database database = properties - .determineDatabase(mockDataSource("jdbc:unknown://localhost")); - assertThat(database).isEqualTo(Database.DEFAULT); + this.contextRunner.run(assertJpaProperties((properties) -> { + Database database = properties + .determineDatabase(mockDataSource("jdbc:unknown://localhost")); + assertThat(database).isEqualTo(Database.DEFAULT); + })); } - private DataSource mockStandaloneDataSource() throws SQLException { - DataSource ds = mock(DataSource.class); - given(ds.getConnection()).willThrow(SQLException.class); - return ds; + 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) { @@ -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 assertJpaProperties( + Consumer consumer) { + return (context) -> { + assertThat(context).hasSingleBean(JpaProperties.class); + consumer.accept(context.getBean(JpaProperties.class)); + }; } @Configuration