From 5e766718596857cceb3c03e71a0e072050d3f431 Mon Sep 17 00:00:00 2001 From: Andy Wilkinson Date: Wed, 13 Apr 2022 18:09:39 +0100 Subject: [PATCH] Remove remaining code that was deprecated in 2.5 Closes gh-30442 --- .../jdbc/DataSourceAutoConfiguration.java | 5 +- ...DataSourceInitializationConfiguration.java | 200 -------- .../jdbc/DataSourceProperties.java | 191 -------- ...itional-spring-configuration-metadata.json | 84 +++- .../DataSourceAutoConfigurationTests.java | 10 - ...aSourceInitializationIntegrationTests.java | 440 ------------------ .../jdbc/DataSourcePropertiesTests.java | 20 - .../JdbcTemplateAutoConfigurationTests.java | 10 - ...tomHibernateJpaAutoConfigurationTests.java | 11 +- .../HibernateDefaultDdlAutoProviderTests.java | 6 +- .../HibernateJpaAutoConfigurationTests.java | 31 -- ...lInitializationAutoConfigurationTests.java | 26 -- 12 files changed, 86 insertions(+), 948 deletions(-) delete mode 100644 spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceInitializationConfiguration.java delete mode 100644 spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceInitializationIntegrationTests.java diff --git a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceAutoConfiguration.java b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceAutoConfiguration.java index 20a2796a9f..56a881a380 100644 --- a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceAutoConfiguration.java +++ b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceAutoConfiguration.java @@ -52,14 +52,11 @@ import org.springframework.util.StringUtils; * @author Kazuki Shimizu * @since 1.0.0 */ -@SuppressWarnings("deprecation") @AutoConfiguration(before = SqlInitializationAutoConfiguration.class) @ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class }) @ConditionalOnMissingBean(type = "io.r2dbc.spi.ConnectionFactory") @EnableConfigurationProperties(DataSourceProperties.class) -@Import({ DataSourcePoolMetadataProvidersConfiguration.class, - DataSourceInitializationConfiguration.InitializationSpecificCredentialsDataSourceInitializationConfiguration.class, - DataSourceInitializationConfiguration.SharedCredentialsDataSourceInitializationConfiguration.class }) +@Import(DataSourcePoolMetadataProvidersConfiguration.class) public class DataSourceAutoConfiguration { @Configuration(proxyBeanMethods = false) diff --git a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceInitializationConfiguration.java b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceInitializationConfiguration.java deleted file mode 100644 index 780187234f..0000000000 --- a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceInitializationConfiguration.java +++ /dev/null @@ -1,200 +0,0 @@ -/* - * Copyright 2012-2021 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. - * You may obtain a copy of the License at - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.springframework.boot.autoconfigure.jdbc; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashSet; -import java.util.List; -import java.util.Set; -import java.util.function.Supplier; -import java.util.stream.Collectors; - -import javax.sql.DataSource; - -import org.springframework.beans.factory.ObjectProvider; -import org.springframework.boot.autoconfigure.condition.AnyNestedCondition; -import org.springframework.boot.autoconfigure.condition.ConditionMessage; -import org.springframework.boot.autoconfigure.condition.ConditionOutcome; -import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; -import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; -import org.springframework.boot.autoconfigure.condition.ConditionalOnSingleCandidate; -import org.springframework.boot.autoconfigure.condition.SpringBootCondition; -import org.springframework.boot.autoconfigure.jdbc.DataSourceInitializationConfiguration.InitializationSpecificCredentialsDataSourceInitializationConfiguration.DifferentCredentialsCondition; -import org.springframework.boot.autoconfigure.jdbc.DataSourceInitializationConfiguration.SharedCredentialsDataSourceInitializationConfiguration.DataSourceInitializationCondition; -import org.springframework.boot.autoconfigure.sql.init.SqlDataSourceScriptDatabaseInitializer; -import org.springframework.boot.jdbc.DataSourceBuilder; -import org.springframework.boot.jdbc.init.DataSourceScriptDatabaseInitializer; -import org.springframework.boot.sql.init.DatabaseInitializationMode; -import org.springframework.boot.sql.init.DatabaseInitializationSettings; -import org.springframework.boot.sql.init.dependency.DatabaseInitializationDependencyConfigurer; -import org.springframework.context.annotation.Bean; -import org.springframework.context.annotation.ConditionContext; -import org.springframework.context.annotation.DependsOn; -import org.springframework.core.env.Environment; -import org.springframework.core.type.AnnotatedTypeMetadata; -import org.springframework.jdbc.datasource.SimpleDriverDataSource; -import org.springframework.util.StringUtils; - -/** - * Configuration for {@link DataSource} initialization using a - * {@link DataSourceScriptDatabaseInitializer} with DDL and DML scripts. - * - * @author Andy Wilkinson - */ -@Deprecated -class DataSourceInitializationConfiguration { - - private static DataSource determineDataSource(Supplier dataSource, String username, String password) { - if (StringUtils.hasText(username) && StringUtils.hasText(password)) { - return DataSourceBuilder.derivedFrom(dataSource.get()).type(SimpleDriverDataSource.class).username(username) - .password(password).build(); - } - return dataSource.get(); - } - - private static List scriptLocations(List locations, String fallback, String platform) { - if (locations != null) { - return locations; - } - List fallbackLocations = new ArrayList<>(); - fallbackLocations.add("optional:classpath*:" + fallback + "-" + platform + ".sql"); - fallbackLocations.add("optional:classpath*:" + fallback + ".sql"); - return fallbackLocations; - } - - private static DatabaseInitializationMode mapMode(org.springframework.boot.jdbc.DataSourceInitializationMode mode) { - switch (mode) { - case ALWAYS: - return DatabaseInitializationMode.ALWAYS; - case EMBEDDED: - return DatabaseInitializationMode.EMBEDDED; - case NEVER: - return DatabaseInitializationMode.NEVER; - default: - throw new IllegalStateException("Unexpected initialization mode '" + mode + "'"); - } - } - - // Fully-qualified to work around javac bug in JDK 1.8 - @org.springframework.context.annotation.Configuration(proxyBeanMethods = false) - @org.springframework.context.annotation.Conditional(DifferentCredentialsCondition.class) - @org.springframework.context.annotation.Import(DatabaseInitializationDependencyConfigurer.class) - @ConditionalOnSingleCandidate(DataSource.class) - @ConditionalOnMissingBean(DataSourceScriptDatabaseInitializer.class) - static class InitializationSpecificCredentialsDataSourceInitializationConfiguration { - - @Bean - SqlDataSourceScriptDatabaseInitializer ddlOnlyScriptDataSourceInitializer(ObjectProvider dataSource, - DataSourceProperties properties) { - DatabaseInitializationSettings settings = new DatabaseInitializationSettings(); - settings.setSchemaLocations(scriptLocations(properties.getSchema(), "schema", properties.getPlatform())); - settings.setContinueOnError(properties.isContinueOnError()); - settings.setSeparator(properties.getSeparator()); - settings.setEncoding(properties.getSqlScriptEncoding()); - settings.setMode(mapMode(properties.getInitializationMode())); - DataSource initializationDataSource = determineDataSource(dataSource::getObject, - properties.getSchemaUsername(), properties.getSchemaPassword()); - return new SqlDataSourceScriptDatabaseInitializer(initializationDataSource, settings); - } - - @Bean - @DependsOn("ddlOnlyScriptDataSourceInitializer") - SqlDataSourceScriptDatabaseInitializer dmlOnlyScriptDataSourceInitializer(ObjectProvider dataSource, - DataSourceProperties properties) { - DatabaseInitializationSettings settings = new DatabaseInitializationSettings(); - settings.setDataLocations(scriptLocations(properties.getData(), "data", properties.getPlatform())); - settings.setContinueOnError(properties.isContinueOnError()); - settings.setSeparator(properties.getSeparator()); - settings.setEncoding(properties.getSqlScriptEncoding()); - settings.setMode(mapMode(properties.getInitializationMode())); - DataSource initializationDataSource = determineDataSource(dataSource::getObject, - properties.getDataUsername(), properties.getDataPassword()); - return new SqlDataSourceScriptDatabaseInitializer(initializationDataSource, settings); - } - - static class DifferentCredentialsCondition extends AnyNestedCondition { - - DifferentCredentialsCondition() { - super(ConfigurationPhase.PARSE_CONFIGURATION); - } - - @ConditionalOnProperty(prefix = "spring.datasource", name = "schema-username") - static class SchemaCredentials { - - } - - @ConditionalOnProperty(prefix = "spring.datasource", name = "data-username") - static class DataCredentials { - - } - - } - - } - - // Fully-qualified to work around javac bug in JDK 1.8 - @org.springframework.context.annotation.Configuration(proxyBeanMethods = false) - @org.springframework.context.annotation.Import(DatabaseInitializationDependencyConfigurer.class) - @org.springframework.context.annotation.Conditional(DataSourceInitializationCondition.class) - @ConditionalOnSingleCandidate(DataSource.class) - @ConditionalOnMissingBean(DataSourceScriptDatabaseInitializer.class) - static class SharedCredentialsDataSourceInitializationConfiguration { - - @Bean - SqlDataSourceScriptDatabaseInitializer scriptDataSourceInitializer(DataSource dataSource, - DataSourceProperties properties) { - DatabaseInitializationSettings settings = new DatabaseInitializationSettings(); - settings.setSchemaLocations(scriptLocations(properties.getSchema(), "schema", properties.getPlatform())); - settings.setDataLocations(scriptLocations(properties.getData(), "data", properties.getPlatform())); - settings.setContinueOnError(properties.isContinueOnError()); - settings.setSeparator(properties.getSeparator()); - settings.setEncoding(properties.getSqlScriptEncoding()); - settings.setMode(mapMode(properties.getInitializationMode())); - return new SqlDataSourceScriptDatabaseInitializer(dataSource, settings); - } - - static class DataSourceInitializationCondition extends SpringBootCondition { - - private static final Set INITIALIZATION_PROPERTIES = Collections - .unmodifiableSet(new HashSet<>(Arrays.asList("spring.datasource.initialization-mode", - "spring.datasource.platform", "spring.datasource.schema", "spring.datasource.schema[0]", - "spring.datasource.schema-username", "spring.datasource.schema-password", - "spring.datasource.data", "spring.datasource.data[0]", "spring.datasource.data-username", - "spring.datasource.data-password", "spring.datasource.continue-on-error", - "spring.datasource.separator", "spring.datasource.sql-script-encoding"))); - - @Override - public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) { - ConditionMessage.Builder message = ConditionMessage.forCondition("DataSource Initialization"); - Environment environment = context.getEnvironment(); - Set configuredProperties = INITIALIZATION_PROPERTIES.stream() - .filter(environment::containsProperty).collect(Collectors.toSet()); - if (configuredProperties.isEmpty()) { - return ConditionOutcome - .noMatch(message.didNotFind("configured properties").items(INITIALIZATION_PROPERTIES)); - } - return ConditionOutcome.match( - message.found("configured property", "configured properties").items(configuredProperties)); - } - - } - - } - -} diff --git a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceProperties.java b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceProperties.java index f6f53a29af..5ef276d740 100644 --- a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceProperties.java +++ b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceProperties.java @@ -16,9 +16,7 @@ package org.springframework.boot.autoconfigure.jdbc; -import java.nio.charset.Charset; import java.util.LinkedHashMap; -import java.util.List; import java.util.Map; import java.util.UUID; @@ -28,7 +26,6 @@ import org.springframework.beans.factory.BeanClassLoaderAware; import org.springframework.beans.factory.BeanCreationException; import org.springframework.beans.factory.InitializingBean; import org.springframework.boot.context.properties.ConfigurationProperties; -import org.springframework.boot.context.properties.DeprecatedConfigurationProperty; import org.springframework.boot.jdbc.DataSourceBuilder; import org.springframework.boot.jdbc.DatabaseDriver; import org.springframework.boot.jdbc.EmbeddedDatabaseConnection; @@ -95,73 +92,6 @@ public class DataSourceProperties implements BeanClassLoaderAware, InitializingB */ private String jndiName; - /** - * Mode to apply when determining if DataSource initialization should be performed - * using the available DDL and DML scripts. - */ - @Deprecated - private org.springframework.boot.jdbc.DataSourceInitializationMode initializationMode = org.springframework.boot.jdbc.DataSourceInitializationMode.EMBEDDED; - - /** - * Platform to use in the DDL or DML scripts (such as schema-${platform}.sql or - * data-${platform}.sql). - */ - @Deprecated - private String platform = "all"; - - /** - * Schema (DDL) script resource references. - */ - private List schema; - - /** - * Username of the database to execute DDL scripts (if different). - */ - @Deprecated - private String schemaUsername; - - /** - * Password of the database to execute DDL scripts (if different). - */ - @Deprecated - private String schemaPassword; - - /** - * Data (DML) script resource references. - */ - @Deprecated - private List data; - - /** - * Username of the database to execute DML scripts (if different). - */ - @Deprecated - private String dataUsername; - - /** - * Password of the database to execute DML scripts (if different). - */ - @Deprecated - private String dataPassword; - - /** - * Whether to stop if an error occurs while initializing the database. - */ - @Deprecated - private boolean continueOnError = false; - - /** - * Statement separator in SQL initialization scripts. - */ - @Deprecated - private String separator = ";"; - - /** - * SQL scripts encoding. - */ - @Deprecated - private Charset sqlScriptEncoding; - /** * Connection details for an embedded database. Defaults to the most suitable embedded * database that is available on the classpath. @@ -391,127 +321,6 @@ public class DataSourceProperties implements BeanClassLoaderAware, InitializingB this.jndiName = jndiName; } - @Deprecated - @DeprecatedConfigurationProperty(replacement = "spring.sql.init.mode") - public org.springframework.boot.jdbc.DataSourceInitializationMode getInitializationMode() { - return this.initializationMode; - } - - @Deprecated - public void setInitializationMode(org.springframework.boot.jdbc.DataSourceInitializationMode initializationMode) { - this.initializationMode = initializationMode; - } - - @Deprecated - @DeprecatedConfigurationProperty(replacement = "spring.sql.init.platform") - public String getPlatform() { - return this.platform; - } - - @Deprecated - public void setPlatform(String platform) { - this.platform = platform; - } - - @Deprecated - @DeprecatedConfigurationProperty(replacement = "spring.sql.init.schema-locations") - public List getSchema() { - return this.schema; - } - - @Deprecated - public void setSchema(List schema) { - this.schema = schema; - } - - @Deprecated - @DeprecatedConfigurationProperty(replacement = "spring.sql.init.username") - public String getSchemaUsername() { - return this.schemaUsername; - } - - @Deprecated - public void setSchemaUsername(String schemaUsername) { - this.schemaUsername = schemaUsername; - } - - @Deprecated - @DeprecatedConfigurationProperty(replacement = "spring.sql.init.password") - public String getSchemaPassword() { - return this.schemaPassword; - } - - @Deprecated - public void setSchemaPassword(String schemaPassword) { - this.schemaPassword = schemaPassword; - } - - @Deprecated - @DeprecatedConfigurationProperty(replacement = "spring.sql.init.data-locations") - public List getData() { - return this.data; - } - - @Deprecated - public void setData(List data) { - this.data = data; - } - - @Deprecated - @DeprecatedConfigurationProperty(replacement = "spring.sql.init.username") - public String getDataUsername() { - return this.dataUsername; - } - - @Deprecated - public void setDataUsername(String dataUsername) { - this.dataUsername = dataUsername; - } - - @Deprecated - @DeprecatedConfigurationProperty(replacement = "spring.sql.init.password") - public String getDataPassword() { - return this.dataPassword; - } - - @Deprecated - public void setDataPassword(String dataPassword) { - this.dataPassword = dataPassword; - } - - @Deprecated - @DeprecatedConfigurationProperty(replacement = "spring.sql.init.continue-on-error") - public boolean isContinueOnError() { - return this.continueOnError; - } - - @Deprecated - public void setContinueOnError(boolean continueOnError) { - this.continueOnError = continueOnError; - } - - @Deprecated - @DeprecatedConfigurationProperty(replacement = "spring.sql.init.separator") - public String getSeparator() { - return this.separator; - } - - @Deprecated - public void setSeparator(String separator) { - this.separator = separator; - } - - @Deprecated - @DeprecatedConfigurationProperty(replacement = "spring.sql.init.encoding") - public Charset getSqlScriptEncoding() { - return this.sqlScriptEncoding; - } - - @Deprecated - public void setSqlScriptEncoding(Charset sqlScriptEncoding) { - this.sqlScriptEncoding = sqlScriptEncoding; - } - public EmbeddedDatabaseConnection getEmbeddedDatabaseConnection() { return this.embeddedDatabaseConnection; } diff --git a/spring-boot-project/spring-boot-autoconfigure/src/main/resources/META-INF/additional-spring-configuration-metadata.json b/spring-boot-project/spring-boot-autoconfigure/src/main/resources/META-INF/additional-spring-configuration-metadata.json index 361e7e4d41..3e30e9cc37 100644 --- a/spring-boot-project/spring-boot-autoconfigure/src/main/resources/META-INF/additional-spring-configuration-metadata.json +++ b/spring-boot-project/spring-boot-autoconfigure/src/main/resources/META-INF/additional-spring-configuration-metadata.json @@ -792,10 +792,41 @@ "defaultValue": "default" }, { - "name": "spring.datasource.initialization-mode", - "defaultValue": "embedded" - }, - { + "name" : "spring.datasource.continue-on-error", + "type" : "java.lang.Boolean", + "deprecation" : { + "level" : "error", + "replacement": "spring.sql.init.continue-on-error" + } + }, { + "name" : "spring.datasource.data", + "type" : "java.util.List", + "deprecation" : { + "level" : "error", + "replacement": "spring.sql.init.data-locations" + } + }, { + "name" : "spring.datasource.data-password", + "type" : "java.lang.String", + "deprecation" : { + "level" : "error", + "replacement": "spring.sql.init.password" + } + }, { + "name" : "spring.datasource.data-username", + "type" : "java.lang.String", + "deprecation" : { + "level" : "error", + "replacement": "spring.sql.init.username" + } + }, { + "name" : "spring.datasource.initialization-mode", + "type" : "org.springframework.boot.jdbc.DataSourceInitializationMode", + "deprecation" : { + "level" : "error", + "replacement": "spring.sql.init.mode" + } + }, { "name": "spring.datasource.jmx-enabled", "type": "java.lang.Boolean", "description": "Whether to enable JMX support (if provided by the underlying pool).", @@ -804,8 +835,49 @@ "level": "error", "replacement": "spring.datasource.tomcat.jmx-enabled" } - }, - { + }, { + "name" : "spring.datasource.platform", + "type" : "java.lang.String", + "deprecation" : { + "level" : "error", + "replacement": "spring.sql.init.platform" + } + }, { + "name" : "spring.datasource.schema", + "type" : "java.util.List", + "deprecation" : { + "level" : "error", + "replacement": "spring.sql.init.schema-locations" + } + }, { + "name" : "spring.datasource.schema-password", + "type" : "java.lang.String", + "deprecation" : { + "level" : "error", + "replacement": "spring.sql.init.password" + } + }, { + "name" : "spring.datasource.schema-username", + "type" : "java.lang.String", + "deprecation" : { + "level" : "error", + "replacement": "spring.sql.init.username" + } + }, { + "name" : "spring.datasource.separator", + "type" : "java.lang.String", + "deprecation" : { + "level" : "error", + "replacement": "spring.sql.init.separator" + } + }, { + "name" : "spring.datasource.sql-script-encoding", + "type" : "java.nio.charset.Charset", + "deprecation" : { + "level" : "error", + "replacement": "spring.sql.init.encoding" + } + }, { "name": "spring.elasticsearch.jest.connection-timeout", "type": "java.time.Duration", "description": "Connection timeout.", diff --git a/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceAutoConfigurationTests.java b/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceAutoConfigurationTests.java index 7cc2f74cf2..a30af3be2a 100644 --- a/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceAutoConfigurationTests.java +++ b/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceAutoConfigurationTests.java @@ -235,16 +235,6 @@ class DataSourceAutoConfigurationTests { .run((context) -> assertThat(context).getBean(DataSource.class).isInstanceOf(EmbeddedDatabase.class)); } - @Test - @Deprecated - void testDataSourceIsInitializedEarly() { - this.contextRunner.withUserConfiguration(TestInitializedDataSourceConfiguration.class) - .withPropertyValues("spring.datasource.initialization-mode=always").run((context) -> { - assertThat(context).hasSingleBean(DataSourceScriptDatabaseInitializer.class); - assertThat(context.getBean(TestInitializedDataSourceConfiguration.class).called).isTrue(); - }); - } - @Test void whenNoInitializationRelatedSpringDataSourcePropertiesAreConfiguredThenInitializationBacksOff() { this.contextRunner diff --git a/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceInitializationIntegrationTests.java b/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceInitializationIntegrationTests.java deleted file mode 100644 index c8a8d279ed..0000000000 --- a/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceInitializationIntegrationTests.java +++ /dev/null @@ -1,440 +0,0 @@ -/* - * Copyright 2012-2021 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. - * You may obtain a copy of the License at - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.springframework.boot.autoconfigure.jdbc; - -import java.io.IOException; -import java.io.PrintWriter; -import java.sql.Connection; -import java.sql.SQLException; -import java.sql.SQLFeatureNotSupportedException; -import java.util.Arrays; -import java.util.Comparator; -import java.util.Random; -import java.util.UUID; -import java.util.concurrent.atomic.AtomicInteger; -import java.util.logging.Logger; - -import javax.sql.DataSource; - -import com.zaxxer.hikari.HikariDataSource; -import org.junit.jupiter.api.Test; - -import org.springframework.beans.factory.BeanCreationException; -import org.springframework.beans.factory.config.BeanFactoryPostProcessor; -import org.springframework.beans.factory.config.BeanPostProcessor; -import org.springframework.boot.autoconfigure.AutoConfigurations; -import org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration; -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.AnnotationConfigApplicationContext; -import org.springframework.context.annotation.Bean; -import org.springframework.context.annotation.Configuration; -import org.springframework.context.annotation.Scope; -import org.springframework.context.support.SimpleThreadScope; -import org.springframework.core.io.DefaultResourceLoader; -import org.springframework.core.io.Resource; -import org.springframework.core.io.ResourceLoader; -import org.springframework.core.io.support.ResourcePatternResolver; -import org.springframework.core.io.support.ResourcePatternUtils; -import org.springframework.jdbc.BadSqlGrammarException; -import org.springframework.jdbc.core.JdbcOperations; -import org.springframework.jdbc.core.JdbcTemplate; -import org.springframework.util.ClassUtils; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.Assertions.assertThatExceptionOfType; - -/** - * Integration tests for DataSource initialization. - * - * @author Dave Syer - * @author Stephane Nicoll - */ -@Deprecated -class DataSourceInitializationIntegrationTests { - - private final ApplicationContextRunner contextRunner = new ApplicationContextRunner() - .withConfiguration(AutoConfigurations.of(DataSourceAutoConfiguration.class)) - .withPropertyValues("spring.datasource.initialization-mode=never", - "spring.datasource.url:jdbc:hsqldb:mem:init-" + UUID.randomUUID()); - - @Test - void dataSourceInitialized() { - this.contextRunner.withPropertyValues("spring.datasource.initialization-mode:always").run((context) -> { - assertThat(context).hasSingleBean(DataSource.class); - DataSource dataSource = context.getBean(DataSource.class); - assertThat(dataSource).isInstanceOf(HikariDataSource.class); - assertDataSourceIsInitialized(dataSource); - }); - } - - @Test - void initializationAppliesToCustomDataSource() { - this.contextRunner.withUserConfiguration(OneDataSource.class) - .withPropertyValues("spring.datasource.initialization-mode:always").run((context) -> { - assertThat(context).hasSingleBean(DataSource.class); - assertDataSourceIsInitialized(context.getBean(DataSource.class)); - }); - } - - @Test - void initializationWithUsernameAndPasswordAppliesToCustomDataSource() { - this.contextRunner.withUserConfiguration(OneDataSource.class) - .withPropertyValues("spring.datasource.initialization-mode:always", - "spring.datasource.schema-username=test", "spring.datasource.schema-password=secret") - .run((context) -> { - assertThat(context).hasSingleBean(DataSource.class); - assertDataSourceIsInitialized(context.getBean(DataSource.class)); - }); - } - - private void assertDataSourceIsInitialized(DataSource dataSource) { - JdbcOperations template = new JdbcTemplate(dataSource); - assertThat(template.queryForObject("SELECT COUNT(*) from BAR", Integer.class)).isEqualTo(1); - } - - @Test - void dataSourceInitializedWithExplicitScript() { - this.contextRunner.withPropertyValues("spring.datasource.initialization-mode:always", - "spring.datasource.schema:" + getRelativeLocationFor("schema.sql"), - "spring.datasource.data:" + getRelativeLocationFor("data.sql")).run((context) -> { - DataSource dataSource = context.getBean(DataSource.class); - assertThat(dataSource).isInstanceOf(HikariDataSource.class); - assertThat(dataSource).isNotNull(); - JdbcOperations template = new JdbcTemplate(dataSource); - assertThat(template.queryForObject("SELECT COUNT(*) from FOO", Integer.class)).isEqualTo(1); - }); - } - - @Test - void dataSourceInitializedWithMultipleScripts() { - this.contextRunner.withPropertyValues("spring.datasource.initialization-mode:always", - "spring.datasource.schema:" + getRelativeLocationFor("schema.sql") + "," - + getRelativeLocationFor("another.sql"), - "spring.datasource.data:" + getRelativeLocationFor("data.sql")).run((context) -> { - DataSource dataSource = context.getBean(DataSource.class); - assertThat(dataSource).isInstanceOf(HikariDataSource.class); - assertThat(dataSource).isNotNull(); - JdbcOperations template = new JdbcTemplate(dataSource); - assertThat(template.queryForObject("SELECT COUNT(*) from FOO", Integer.class)).isEqualTo(1); - assertThat(template.queryForObject("SELECT COUNT(*) from SPAM", Integer.class)).isEqualTo(0); - }); - } - - @Test - void dataSourceInitializedWithExplicitSqlScriptEncoding() { - this.contextRunner.withPropertyValues("spring.datasource.initialization-mode:always", - "spring.datasource.sqlScriptEncoding:UTF-8", - "spring.datasource.schema:" + getRelativeLocationFor("encoding-schema.sql"), - "spring.datasource.data:" + getRelativeLocationFor("encoding-data.sql")).run((context) -> { - DataSource dataSource = context.getBean(DataSource.class); - assertThat(dataSource).isInstanceOf(HikariDataSource.class); - assertThat(dataSource).isNotNull(); - JdbcOperations template = new JdbcTemplate(dataSource); - assertThat(template.queryForObject("SELECT COUNT(*) from BAR", Integer.class)).isEqualTo(2); - assertThat(template.queryForObject("SELECT name from BAR WHERE id=1", String.class)) - .isEqualTo("bar"); - assertThat(template.queryForObject("SELECT name from BAR WHERE id=2", String.class)) - .isEqualTo("ばー"); - }); - } - - @Test - void initializationDisabled() { - this.contextRunner.run(assertInitializationIsDisabled()); - } - - @Test - void initializationDoesNotApplyWithSeveralDataSources() { - this.contextRunner.withUserConfiguration(TwoDataSources.class) - .withPropertyValues("spring.datasource.initialization-mode:always").run((context) -> { - assertThat(context.getBeanNamesForType(DataSource.class)).hasSize(2); - assertDataSourceNotInitialized(context.getBean("oneDataSource", DataSource.class)); - assertDataSourceNotInitialized(context.getBean("twoDataSource", DataSource.class)); - }); - } - - private ContextConsumer assertInitializationIsDisabled() { - return (context) -> { - assertThat(context).hasSingleBean(DataSource.class); - DataSource dataSource = context.getBean(DataSource.class); - assertDataSourceNotInitialized(dataSource); - }; - } - - private void assertDataSourceNotInitialized(DataSource dataSource) { - JdbcOperations template = new JdbcTemplate(dataSource); - assertThatExceptionOfType(BadSqlGrammarException.class) - .isThrownBy(() -> template.queryForObject("SELECT COUNT(*) from BAR", Integer.class)) - .satisfies((ex) -> { - SQLException sqlException = ex.getSQLException(); - int expectedCode = -5501; // user lacks privilege or object not found - assertThat(sqlException.getErrorCode()).isEqualTo(expectedCode); - }); - } - - @Test - void dataSourceInitializedWithSchemaCredentials() { - this.contextRunner - .withPropertyValues("spring.datasource.initialization-mode:always", - "spring.datasource.sqlScriptEncoding:UTF-8", - "spring.datasource.schema:" + getRelativeLocationFor("encoding-schema.sql"), - "spring.datasource.data:" + getRelativeLocationFor("encoding-data.sql"), - "spring.datasource.schema-username:admin", "spring.datasource.schema-password:admin") - .run((context) -> { - assertThat(context).hasFailed(); - assertThat(context.getStartupFailure()).isInstanceOf(BeanCreationException.class) - .hasMessageContaining("invalid authorization specification"); - context.getStartupFailure().printStackTrace(); - }); - } - - @Test - void dataSourceInitializedWithDataCredentials() { - this.contextRunner - .withPropertyValues("spring.datasource.initialization-mode:always", - "spring.datasource.sqlScriptEncoding:UTF-8", - "spring.datasource.schema:" + getRelativeLocationFor("encoding-schema.sql"), - "spring.datasource.data:" + getRelativeLocationFor("encoding-data.sql"), - "spring.datasource.data-username:admin", "spring.datasource.data-password:admin") - .run((context) -> { - assertThat(context).hasFailed(); - assertThat(context.getStartupFailure()).isInstanceOf(BeanCreationException.class) - .hasMessageContaining("invalid authorization specification"); - }); - } - - @Test - void multipleScriptsAppliedInLexicalOrder() { - new ApplicationContextRunner(() -> { - AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(); - context.setResourceLoader(new ReverseOrderResourceLoader(new DefaultResourceLoader())); - return context; - }).withConfiguration(AutoConfigurations.of(DataSourceAutoConfiguration.class)) - .withPropertyValues("spring.datasource.initialization-mode=always", - "spring.datasource.url:jdbc:hsqldb:mem:testdb-" + new Random().nextInt(), - "spring.datasource.schema:classpath*:" + getRelativeLocationFor("lexical-schema-*.sql"), - "spring.datasource.data:classpath*:" + getRelativeLocationFor("data.sql")) - .run((context) -> { - DataSource dataSource = context.getBean(DataSource.class); - assertThat(dataSource).isInstanceOf(HikariDataSource.class); - assertThat(dataSource).isNotNull(); - JdbcOperations template = new JdbcTemplate(dataSource); - assertThat(template.queryForObject("SELECT COUNT(*) from FOO", Integer.class)).isEqualTo(1); - }); - } - - @Test - void testDataSourceInitializedWithInvalidSchemaResource() { - this.contextRunner.withPropertyValues("spring.datasource.initialization-mode:always", - "spring.datasource.schema:classpath:does/not/exist.sql").run((context) -> { - assertThat(context).hasFailed(); - assertThat(context.getStartupFailure()).isInstanceOf(BeanCreationException.class); - assertThat(context.getStartupFailure()) - .hasMessageContaining("No schema scripts found at location 'classpath:does/not/exist.sql'"); - }); - } - - @Test - void dataSourceInitializedWithInvalidDataResource() { - this.contextRunner.withPropertyValues("spring.datasource.initialization-mode:always", - "spring.datasource.schema:" + getRelativeLocationFor("schema.sql"), - "spring.datasource.data:classpath:does/not/exist.sql").run((context) -> { - assertThat(context).hasFailed(); - assertThat(context.getStartupFailure()).isInstanceOf(BeanCreationException.class); - assertThat(context.getStartupFailure()) - .hasMessageContaining("No data scripts found at location 'classpath:does/not/exist.sql'"); - }); - } - - @Test - void whenDataSourceIsProxiedByABeanPostProcessorThenDataSourceInitializationUsesTheProxy() { - this.contextRunner.withPropertyValues("spring.datasource.initialization-mode:always") - .withUserConfiguration(DataSourceProxyConfiguration.class).run((context) -> { - assertThat(context).hasSingleBean(DataSource.class); - DataSource dataSource = context.getBean(DataSource.class); - assertThat(dataSource).isInstanceOf(DataSourceProxy.class); - assertThat(((DataSourceProxy) dataSource).connectionsRetrieved).hasPositiveValue(); - assertDataSourceIsInitialized(dataSource); - }); - } - - @Test - // gh-13042 - void whenDataSourceIsScopedAndJpaIsInvolvedThenInitializationCompletesSuccessfully() { - this.contextRunner.withPropertyValues("spring.datasource.initialization-mode:always") - .withConfiguration(AutoConfigurations.of(HibernateJpaAutoConfiguration.class)) - .withUserConfiguration(ScopedDataSourceConfiguration.class).run((context) -> { - assertThat(context).hasSingleBean(DataSource.class); - DataSource dataSource = context.getBean(DataSource.class); - assertThat(dataSource).isInstanceOf(HikariDataSource.class); - assertDataSourceIsInitialized(dataSource); - }); - } - - private String getRelativeLocationFor(String resource) { - return ClassUtils.addResourcePathToPackagePath(getClass(), resource); - } - - @Configuration(proxyBeanMethods = false) - static class OneDataSource { - - @Bean - DataSource oneDataSource() { - return new TestDataSource(true); - } - - } - - @Configuration(proxyBeanMethods = false) - static class TwoDataSources extends OneDataSource { - - @Bean - DataSource twoDataSource() { - return new TestDataSource(true); - } - - } - - /** - * {@link ResourcePatternResolver} used to ensure consistently wrong resource - * ordering. - */ - static class ReverseOrderResourceLoader implements ResourcePatternResolver { - - private final ResourcePatternResolver resolver; - - ReverseOrderResourceLoader(ResourceLoader loader) { - this.resolver = ResourcePatternUtils.getResourcePatternResolver(loader); - } - - @Override - public Resource getResource(String location) { - return this.resolver.getResource(location); - } - - @Override - public ClassLoader getClassLoader() { - return this.resolver.getClassLoader(); - } - - @Override - public Resource[] getResources(String locationPattern) throws IOException { - Resource[] resources = this.resolver.getResources(locationPattern); - Arrays.sort(resources, Comparator.comparing(Resource::getFilename).reversed()); - return resources; - } - - } - - @Configuration(proxyBeanMethods = true) - static class DataSourceProxyConfiguration { - - @Bean - static BeanPostProcessor dataSourceProxy() { - return new BeanPostProcessor() { - - @Override - public Object postProcessAfterInitialization(Object bean, String beanName) { - if (bean instanceof DataSource) { - return new DataSourceProxy((DataSource) bean); - } - return bean; - } - - }; - } - - } - - static class DataSourceProxy implements DataSource { - - private final AtomicInteger connectionsRetrieved = new AtomicInteger(); - - private final DataSource delegate; - - DataSourceProxy(DataSource delegate) { - this.delegate = delegate; - } - - @Override - public PrintWriter getLogWriter() throws SQLException { - return this.delegate.getLogWriter(); - } - - @Override - public void setLogWriter(PrintWriter out) throws SQLException { - this.delegate.setLogWriter(out); - } - - @Override - public boolean isWrapperFor(Class iface) throws SQLException { - return this.delegate.isWrapperFor(iface); - } - - @Override - public T unwrap(Class iface) throws SQLException { - return this.delegate.unwrap(iface); - } - - @Override - public Connection getConnection() throws SQLException { - this.connectionsRetrieved.incrementAndGet(); - return this.delegate.getConnection(); - } - - @Override - public Connection getConnection(String username, String password) throws SQLException { - this.connectionsRetrieved.incrementAndGet(); - return this.delegate.getConnection(username, password); - } - - @Override - public int getLoginTimeout() throws SQLException { - return this.delegate.getLoginTimeout(); - } - - @Override - public void setLoginTimeout(int seconds) throws SQLException { - this.delegate.setLoginTimeout(seconds); - } - - @Override - public Logger getParentLogger() throws SQLFeatureNotSupportedException { - return this.delegate.getParentLogger(); - } - - } - - @Configuration(proxyBeanMethods = false) - static class ScopedDataSourceConfiguration { - - @Bean - static BeanFactoryPostProcessor fooScope() { - return (beanFactory) -> beanFactory.registerScope("test", new SimpleThreadScope()); - } - - @Bean - @Scope("test") - HikariDataSource dataSource(DataSourceProperties properties) { - return properties.initializeDataSourceBuilder().type(HikariDataSource.class).build(); - } - - } - -} diff --git a/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourcePropertiesTests.java b/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourcePropertiesTests.java index 74b9ad9ef4..31ebbe23bd 100644 --- a/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourcePropertiesTests.java +++ b/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourcePropertiesTests.java @@ -178,24 +178,4 @@ class DataSourcePropertiesTests { assertThat(properties.determinePassword()).isNull(); } - @Test - @Deprecated - void determineCredentialsForSchemaScripts() { - DataSourceProperties properties = new DataSourceProperties(); - properties.setSchemaUsername("foo"); - properties.setSchemaPassword("bar"); - assertThat(properties.getSchemaUsername()).isEqualTo("foo"); - assertThat(properties.getSchemaPassword()).isEqualTo("bar"); - } - - @Test - @Deprecated - void determineCredentialsForDataScripts() { - DataSourceProperties properties = new DataSourceProperties(); - properties.setDataUsername("foo"); - properties.setDataPassword("bar"); - assertThat(properties.getDataUsername()).isEqualTo("foo"); - assertThat(properties.getDataPassword()).isEqualTo("bar"); - } - } diff --git a/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/JdbcTemplateAutoConfigurationTests.java b/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/JdbcTemplateAutoConfigurationTests.java index 5f51ab8b73..c6c8e4bd67 100644 --- a/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/JdbcTemplateAutoConfigurationTests.java +++ b/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/JdbcTemplateAutoConfigurationTests.java @@ -145,16 +145,6 @@ class JdbcTemplateAutoConfigurationTests { }); } - @Test - @Deprecated - void testDependencyToDeprecatedDataSourceInitialization() { - this.contextRunner.withUserConfiguration(DataSourceInitializationValidator.class) - .withPropertyValues("spring.datasource.initialization-mode=always").run((context) -> { - assertThat(context).hasNotFailed(); - assertThat(context.getBean(DataSourceInitializationValidator.class).count).isEqualTo(1); - }); - } - @Test void testDependencyToScriptBasedDataSourceInitialization() { this.contextRunner.withConfiguration(AutoConfigurations.of(SqlInitializationAutoConfiguration.class)) diff --git a/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/orm/jpa/CustomHibernateJpaAutoConfigurationTests.java b/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/orm/jpa/CustomHibernateJpaAutoConfigurationTests.java index 72d592f6a6..9fb19d6bfc 100644 --- a/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/orm/jpa/CustomHibernateJpaAutoConfigurationTests.java +++ b/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/orm/jpa/CustomHibernateJpaAutoConfigurationTests.java @@ -96,12 +96,11 @@ class CustomHibernateJpaAutoConfigurationTests { @Test void defaultDatabaseIsSet() { - this.contextRunner.withPropertyValues("spring.datasource.url:jdbc:h2:mem:testdb", - "spring.datasource.initialization-mode:never").run((context) -> { - HibernateJpaVendorAdapter bean = context.getBean(HibernateJpaVendorAdapter.class); - Database database = (Database) ReflectionTestUtils.getField(bean, "database"); - assertThat(database).isEqualTo(Database.DEFAULT); - }); + this.contextRunner.withPropertyValues("spring.datasource.url:jdbc:h2:mem:testdb").run((context) -> { + HibernateJpaVendorAdapter bean = context.getBean(HibernateJpaVendorAdapter.class); + Database database = (Database) ReflectionTestUtils.getField(bean, "database"); + assertThat(database).isEqualTo(Database.DEFAULT); + }); } @Configuration(proxyBeanMethods = false) diff --git a/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/orm/jpa/HibernateDefaultDdlAutoProviderTests.java b/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/orm/jpa/HibernateDefaultDdlAutoProviderTests.java index 14e0cffd26..f252cd8609 100644 --- a/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/orm/jpa/HibernateDefaultDdlAutoProviderTests.java +++ b/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/orm/jpa/HibernateDefaultDdlAutoProviderTests.java @@ -39,10 +39,8 @@ import static org.mockito.Mockito.mock; */ class HibernateDefaultDdlAutoProviderTests { - private final ApplicationContextRunner contextRunner = new ApplicationContextRunner() - .withConfiguration( - AutoConfigurations.of(DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class)) - .withPropertyValues("spring.datasource.initialization-mode:never"); + private final ApplicationContextRunner contextRunner = new ApplicationContextRunner().withConfiguration( + AutoConfigurations.of(DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class)); @Test void defaultDDlAutoForEmbedded() { diff --git a/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/orm/jpa/HibernateJpaAutoConfigurationTests.java b/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/orm/jpa/HibernateJpaAutoConfigurationTests.java index 90e605fc8f..a4b215b5f3 100644 --- a/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/orm/jpa/HibernateJpaAutoConfigurationTests.java +++ b/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/orm/jpa/HibernateJpaAutoConfigurationTests.java @@ -97,17 +97,6 @@ class HibernateJpaAutoConfigurationTests extends AbstractJpaAutoConfigurationTes super(HibernateJpaAutoConfiguration.class); } - @Test - @Deprecated - void testDataScriptWithDeprecatedMissingDdl() { - contextRunner().withPropertyValues("spring.datasource.data:classpath:/city.sql", - // Missing: - "spring.datasource.schema:classpath:/ddl.sql").run((context) -> { - assertThat(context).hasFailed(); - assertThat(context.getStartupFailure()).hasMessageContaining("ddl.sql"); - }); - } - @Test void testDmlScriptWithMissingDdl() { contextRunner().withPropertyValues("spring.sql.init.data-locations:classpath:/city.sql", @@ -118,16 +107,6 @@ class HibernateJpaAutoConfigurationTests extends AbstractJpaAutoConfigurationTes }); } - @Test - void testDataScript() { - // This can't succeed because the data SQL is executed immediately after the - // schema and Hibernate hasn't initialized yet at that point - contextRunner().withPropertyValues("spring.datasource.data:classpath:/city.sql").run((context) -> { - assertThat(context).hasFailed(); - assertThat(context.getStartupFailure()).isInstanceOf(BeanCreationException.class); - }); - } - @Test void testDmlScript() { // This can't succeed because the data SQL is executed immediately after the @@ -138,16 +117,6 @@ class HibernateJpaAutoConfigurationTests extends AbstractJpaAutoConfigurationTes }); } - @Test - @Deprecated - void testDataScriptRunsEarly() { - contextRunner().withUserConfiguration(TestInitializedJpaConfiguration.class) - .withClassLoader(new HideDataScriptClassLoader()) - .withPropertyValues("spring.jpa.show-sql=true", "spring.jpa.hibernate.ddl-auto:create-drop", - "spring.datasource.data:classpath:/city.sql", "spring.jpa.defer-datasource-initialization=true") - .run((context) -> assertThat(context.getBean(TestInitializedJpaConfiguration.class).called).isTrue()); - } - @Test void testDmlScriptRunsEarly() { contextRunner().withUserConfiguration(TestInitializedJpaConfiguration.class) diff --git a/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/sql/init/SqlInitializationAutoConfigurationTests.java b/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/sql/init/SqlInitializationAutoConfigurationTests.java index c733ee39d8..3ddb1932d9 100644 --- a/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/sql/init/SqlInitializationAutoConfigurationTests.java +++ b/spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/sql/init/SqlInitializationAutoConfigurationTests.java @@ -67,14 +67,6 @@ class SqlInitializationAutoConfigurationTests { .run((context) -> assertThat(context).hasSingleBean(R2dbcScriptDatabaseInitializer.class)); } - @Test - @Deprecated - void whenConnectionFactoryIsAvailableAndInitializationIsDisabledThenInitializerIsNotAutoConfigured() { - this.contextRunner.withConfiguration(AutoConfigurations.of(R2dbcAutoConfiguration.class)) - .withPropertyValues("spring.sql.init.enabled:false") - .run((context) -> assertThat(context).doesNotHaveBean(AbstractScriptDatabaseInitializer.class)); - } - @Test void whenConnectionFactoryIsAvailableAndModeIsNeverThenInitializerIsNotAutoConfigured() { this.contextRunner.withConfiguration(AutoConfigurations.of(R2dbcAutoConfiguration.class)) @@ -89,14 +81,6 @@ class SqlInitializationAutoConfigurationTests { .run((context) -> assertThat(context).hasSingleBean(DataSourceScriptDatabaseInitializer.class)); } - @Test - @Deprecated - void whenDataSourceIsAvailableAndInitializationIsDisabledThenInitializerIsNotAutoConfigured() { - this.contextRunner.withConfiguration(AutoConfigurations.of(DataSourceAutoConfiguration.class)) - .withPropertyValues("spring.sql.init.enabled:false") - .run((context) -> assertThat(context).doesNotHaveBean(AbstractScriptDatabaseInitializer.class)); - } - @Test void whenDataSourceIsAvailableAndModeIsNeverThenThenInitializerIsNotAutoConfigured() { this.contextRunner.withConfiguration(AutoConfigurations.of(DataSourceAutoConfiguration.class)) @@ -170,16 +154,6 @@ class SqlInitializationAutoConfigurationTests { }); } - @Test - void whenDataSourceAutoConfigurationHasDefinedAnInitializerThenAutoConfigurationBacksOff() { - this.contextRunner.withConfiguration(AutoConfigurations.of(DataSourceAutoConfiguration.class)) - .withPropertyValues("spring.datasource.schema=classpath:schema.sql") - .withInitializer(new ConditionEvaluationReportLoggingListener(LogLevel.INFO)).run((context) -> { - assertThat(context).hasSingleBean(SqlDataSourceScriptDatabaseInitializer.class); - assertThat(context).hasBean("scriptDataSourceInitializer"); - }); - } - @Configuration(proxyBeanMethods = false) static class SqlDatabaseInitializerConfiguration {