Add EnvironmentConfigurationValueProvider for Liquibase property pass-through

Signed-off-by: Dylan Miska <[email protected]>

Author: dmiska25

module/spring-boot-liquibase/src/main/java/org/springframework/boot/liquibase/autoconfigure/EnvironmentConfigurationValueProvider.java

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2012-present 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.liquibase.autoconfigure;
+
+import liquibase.configuration.AbstractConfigurationValueProvider;
+import liquibase.configuration.ProvidedValue;
+import org.jspecify.annotations.Nullable;
+import org.springframework.core.env.Environment;
+import org.springframework.util.Assert;
+
+/**
+ * A Liquibase {@code ConfigurationValueProvider} that passes through properties defined
+ * in the Spring {@link Environment} using the exact-name convention:
+ *
+ * <pre>
+ * spring.liquibase.properties.&lt;liquibaseKey&gt; = &lt;value&gt;
+ * </pre>
+ *
+ * For example: <pre>
+ * spring.liquibase.properties.liquibase.duplicateFileMode = WARN
+ * spring.liquibase.properties.liquibase.searchPath = classpath:/db,file:./external
+ * </pre>
+ *
+ * No relaxed binding or key transformation is performed. Keys are looked up exactly as
+ * provided by Liquibase (including dots and casing), prefixed with
+ * {@code spring.liquibase.properties.}.
+ */
+final class EnvironmentConfigurationValueProvider extends AbstractConfigurationValueProvider {
+
+	private static final String PREFIX = "spring.liquibase.properties.";
+
+	private final Environment environment;
+
+	EnvironmentConfigurationValueProvider(Environment environment) {
+		Assert.notNull(environment, "Environment must not be null");
+		this.environment = environment;
+	}
+
+	@Override
+	public int getPrecedence() {
+		return 100;
+	}
+
+	@Override
+	public @Nullable ProvidedValue getProvidedValue(String... keyAndAliases) {
+		if (keyAndAliases == null) {
+			return null;
+		}
+		for (String requestedKey : keyAndAliases) {
+			if (requestedKey == null) {
+				continue;
+			}
+			// Exact pass-through: no rewriting of the Liquibase key
+			String propertyName = PREFIX + requestedKey;
+			String value = this.environment.getProperty(propertyName);
+			if (value != null) {
+				// requestedKey: the key Liquibase asked for
+				// propertyName: the exact Spring Environment property we read
+				return new ProvidedValue(requestedKey, requestedKey, value,
+						"Spring Environment property '" + propertyName + "'", this);
+			}
+		}
+		return null;
+	}
+
+}

module/spring-boot-liquibase/src/main/java/org/springframework/boot/liquibase/autoconfigure/LiquibaseAutoConfiguration.java

@@ -30,6 +30,7 @@
 import org.springframework.aot.hint.RuntimeHints;
 import org.springframework.aot.hint.RuntimeHintsRegistrar;
 import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
 import org.springframework.boot.autoconfigure.AutoConfiguration;
 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
 import org.springframework.boot.autoconfigure.condition.AnyNestedCondition;
@@ -50,6 +51,7 @@
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Import;
 import org.springframework.context.annotation.ImportRuntimeHints;
+import org.springframework.core.env.Environment;
 import org.springframework.jdbc.core.ConnectionCallback;
 import org.springframework.jdbc.datasource.SimpleDriverDataSource;
 import org.springframework.util.Assert;
@@ -188,6 +190,24 @@ private void applyConnectionDetails(LiquibaseConnectionDetails connectionDetails
 
 	}
 
+	@Bean
+	static BeanFactoryPostProcessor liquibaseConfigurationValueProviderRegistrar(Environment environment) {
+
+		return (beanFactory) -> {
+			var liquibaseConfiguration = liquibase.Scope.getCurrentScope()
+				.getSingleton(liquibase.configuration.LiquibaseConfiguration.class);
+
+			// Remove any previously registered instance of our provider class
+			liquibaseConfiguration.getProviders()
+				.stream()
+				.filter((provider) -> provider.getClass() == EnvironmentConfigurationValueProvider.class)
+				.toList()
+				.forEach(liquibaseConfiguration::unregisterProvider);
+
+			liquibaseConfiguration.registerProvider(new EnvironmentConfigurationValueProvider(environment));
+		};
+	}
+
 	@ConditionalOnClass(Customizer.class)
 	@Configuration(proxyBeanMethods = false)
 	static class CustomizerConfiguration {

module/spring-boot-liquibase/src/main/java/org/springframework/boot/liquibase/autoconfigure/LiquibaseProperties.java

@@ -123,6 +123,15 @@ public class LiquibaseProperties {
 	 */
 	private @Nullable Map<String, String> parameters;
 
+	/**
+	 * Liquibase global configuration properties. Properties must be set with liquibase's
+	 * full propertiesFile dot format. For example:
+	 * {@code spring.liquibase.properties.liquibase.duplicateFileMode}. Note that
+	 * Liquibase’s normal precedence still applies (env variables and jvm system
+	 * properties can override values set here).
+	 */
+	private @Nullable Map<String, String> properties;
+
 	/**
 	 * File to which rollback SQL is written when an update is performed.
 	 */
@@ -294,6 +303,14 @@ public void setParameters(@Nullable Map<String, String> parameters) {
 		this.parameters = parameters;
 	}
 
+	public @Nullable Map<String, String> getProperties() {
+		return this.properties;
+	}
+
+	public void setProperties(@Nullable Map<String, String> properties) {
+		this.properties = properties;
+	}
+
 	public @Nullable File getRollbackFile() {
 		return this.rollbackFile;
 	}

module/spring-boot-liquibase/src/test/java/org/springframework/boot/liquibase/autoconfigure/EnvironmentConfigurationValueProviderTests.java

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2012-present 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.liquibase.autoconfigure;
+
+import liquibase.configuration.ProvidedValue;
+import org.junit.jupiter.api.Test;
+import org.springframework.mock.env.MockEnvironment;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class EnvironmentConfigurationValueProviderTests {
+
+	@Test
+	void precedenceIsBetweenDefaultsAndEnvVars() {
+		var env = new MockEnvironment();
+		var provider = new EnvironmentConfigurationValueProvider(env);
+		assertThat(provider.getPrecedence()).isEqualTo(100);
+	}
+
+	@Test
+	void returnsProvidedValueWhenExactPropertyPresent() {
+		var env = new MockEnvironment().withProperty("spring.liquibase.properties.liquibase.duplicateFileMode", "WARN");
+		var provider = new EnvironmentConfigurationValueProvider(env);
+
+		ProvidedValue value = provider.getProvidedValue("liquibase.duplicateFileMode");
+
+		assertThat(value).isNotNull();
+		assertThat(String.valueOf(value.getValue())).isEqualTo("WARN");
+		assertThat(value.getActualKey()).isEqualTo("liquibase.duplicateFileMode");
+		assertThat(value.getSourceDescription())
+			.contains("Spring Environment property 'spring.liquibase.properties.liquibase.duplicateFileMode'");
+	}
+
+	@Test
+	void returnsNullWhenNoKeysProvided() {
+		var env = new MockEnvironment();
+		var provider = new EnvironmentConfigurationValueProvider(env);
+
+		ProvidedValue value = provider.getProvidedValue((String[]) null);
+
+		assertThat(value).isNull();
+	}
+
+	@Test
+	void returnsNullWhenNoMatchingProperty() {
+		var env = new MockEnvironment();
+		var provider = new EnvironmentConfigurationValueProvider(env);
+
+		ProvidedValue value = provider.getProvidedValue("liquibase.searchPath");
+
+		assertThat(value).isNull();
+	}
+
+	@Test
+	void skipsNullKeysAndResolvesFirstMatchingNonNull() {
+		var env = new MockEnvironment()
+			// Only the second alias is present
+			.withProperty("spring.liquibase.properties.liquibase.searchPath", "classpath:/db");
+		var provider = new EnvironmentConfigurationValueProvider(env);
+
+		ProvidedValue value = provider.getProvidedValue(null, "liquibase.searchPath");
+
+		assertThat(value).isNotNull();
+		assertThat(String.valueOf(value.getValue())).isEqualTo("classpath:/db");
+		assertThat(value.getActualKey()).isEqualTo("liquibase.searchPath");
+	}
+
+	@Test
+	void doesNotApplyRelaxedBinding_exactKeyOnly() {
+		var env = new MockEnvironment().withProperty("spring.liquibase.properties.liquibase.duplicate-file-mode",
+				"WARN");
+		var provider = new EnvironmentConfigurationValueProvider(env);
+
+		// Request camelCase; should not match the kebab-case property
+		ProvidedValue value = provider.getProvidedValue("liquibase.duplicateFileMode");
+
+		assertThat(value).isNull();
+	}
+
+}

module/spring-boot-liquibase/src/test/java/org/springframework/boot/liquibase/autoconfigure/LiquibaseAutoConfigurationTests.java

@@ -563,6 +563,92 @@ void shouldRegisterHints() {
 		assertThat(RuntimeHintsPredicates.resource().forResource("db/changelog/tables/init.sql")).accepts(hints);
 	}
 
+	@Test
+	@WithDbChangelogMasterYamlResource
+	void springLiquibaseTakesPrecedenceOverLiquibaseDefaults() {
+		this.contextRunner.withUserConfiguration(EmbeddedDataSourceConfiguration.class)
+			.withPropertyValues("spring.liquibase.properties.liquibase.duplicateFileMode=WARN")
+			.run((context) -> {
+				assertThat(context).hasSingleBean(SpringLiquibase.class);
+
+				var liquibaseConfig = liquibase.Scope.getCurrentScope()
+					.getSingleton(liquibase.configuration.LiquibaseConfiguration.class);
+
+				var provider = liquibaseConfig.getProviders()
+					.stream()
+					.filter(p -> p.getClass()
+						.getName()
+						.equals("org.springframework.boot.liquibase.autoconfigure.EnvironmentConfigurationValueProvider"))
+					.findFirst()
+					.orElseThrow();
+
+				var provided = provider.getProvidedValue("liquibase.duplicateFileMode");
+				assertThat(provided).isNotNull();
+				assertThat(String.valueOf(provided.getValue())).isEqualTo("WARN");
+
+				// Now check the resolved value, which should be different from the
+				// default 'ERROR'
+				var resolved = liquibaseConfig.getCurrentConfiguredValue(null, null, "liquibase.duplicateFileMode");
+				assertThat(String.valueOf(resolved.getValue())).isEqualTo("WARN");
+			});
+	}
+
+	@Test
+	@WithDbChangelogMasterYamlResource
+	void systemPropertyTakesPrecedenceOverSpringLiquibaseProperties() {
+		this.contextRunner.withSystemProperties("liquibase.duplicateFileMode=ERROR")
+			.withUserConfiguration(EmbeddedDataSourceConfiguration.class)
+			.withPropertyValues("spring.liquibase.properties.liquibase.duplicateFileMode=WARN")
+			.run((context) -> {
+				assertThat(context).hasSingleBean(SpringLiquibase.class);
+
+				var liquibaseConfig = liquibase.Scope.getCurrentScope()
+					.getSingleton(liquibase.configuration.LiquibaseConfiguration.class);
+
+				var provider = liquibaseConfig.getProviders()
+					.stream()
+					.filter(p -> p.getClass()
+						.getName()
+						.equals("org.springframework.boot.liquibase.autoconfigure.EnvironmentConfigurationValueProvider"))
+					.findFirst()
+					.orElseThrow();
+
+				// Our provider should return the value set through Spring property
+				var providedBySpring = provider.getProvidedValue("liquibase.duplicateFileMode");
+				assertThat(providedBySpring).isNotNull();
+				assertThat(String.valueOf(providedBySpring.getValue())).isEqualTo("WARN");
+
+				// Now check the resolved value, which should be the system property
+				var resolved = liquibaseConfig.getCurrentConfiguredValue(null, null, "liquibase.duplicateFileMode");
+				assertThat(String.valueOf(resolved.getValue())).isEqualTo("ERROR");
+			});
+	}
+
+	@Test
+	@WithDbChangelogMasterYamlResource
+	void arbitraryLiquibaseKeyIsPassedThroughAsIs() {
+		this.contextRunner.withUserConfiguration(EmbeddedDataSourceConfiguration.class)
+			.withPropertyValues("spring.liquibase.properties.my.extension.custom.option=true")
+			.run((context) -> {
+				assertThat(context).hasSingleBean(SpringLiquibase.class);
+
+				var liquibaseConfig = liquibase.Scope.getCurrentScope()
+					.getSingleton(liquibase.configuration.LiquibaseConfiguration.class);
+
+				var provider = liquibaseConfig.getProviders()
+					.stream()
+					.filter(p -> p.getClass()
+						.getName()
+						.equals("org.springframework.boot.liquibase.autoconfigure.EnvironmentConfigurationValueProvider"))
+					.findFirst()
+					.orElseThrow();
+
+				var provided = provider.getProvidedValue("my.extension.custom.option");
+				assertThat(provided).isNotNull();
+				assertThat(String.valueOf(provided.getValue())).isEqualTo("true");
+			});
+	}
+
 	@Test
 	@WithDbChangelogMasterYamlResource
 	void whenCustomizerBeanIsDefinedThenItIsConfiguredOnSpringLiquibase() {