From 6a952a7b793653eed43bac0d21f9860ff170fa12 Mon Sep 17 00:00:00 2001 From: Lucian Holland Date: Tue, 10 Nov 2020 12:17:38 +0100 Subject: [PATCH] PR review changes QUES-36 Moved test utilities + deps to commons-testing project Got rid of unhelpful marker interfaces Add some testing (unit + integration) for SpringBootConfigStorage --- .../config/AbstractMutableConfigStorage.java | 14 +++ .../com/pkb/common/config/ConfigStorage.java | 5 +- .../common/config/ConfigStorageFactory.java | 2 +- .../common/config/ImmutableConfigStorage.java | 30 ------ .../config/ImmutableRawConfigStorage.java | 23 ++++- .../common/config/MutableConfigStorage.java | 10 -- .../config/MutableRawConfigStorage.java | 22 ++--- .../config/ImmutableRawConfigStorageTest.java | 6 -- .../config/MutableRawConfigStorageTest.java | 6 -- pom.xml | 14 ++- spring-boot-infrastructure/pom.xml | 47 +++++++--- ...urationPropertiesScopingPostProcessor.java | 15 ++- .../config/SpringBootConfigStorage.java | 18 ++-- .../pkb/common/testing/IntegrationTest.java | 28 ------ ...pringBootConfigStorageIntegrationTest.java | 80 ++++++++++++++++ .../config/SpringBootConfigStorageTest.java | 94 +++++++++++++++++++ .../src/test/resources/application.properties | 2 + 17 files changed, 283 insertions(+), 133 deletions(-) create mode 100644 config/src/main/java/com/pkb/common/config/AbstractMutableConfigStorage.java delete mode 100644 config/src/main/java/com/pkb/common/config/ImmutableConfigStorage.java delete mode 100644 config/src/main/java/com/pkb/common/config/MutableConfigStorage.java delete mode 100644 spring-boot-infrastructure/src/main/java/com/pkb/common/testing/IntegrationTest.java create mode 100644 spring-boot-infrastructure/src/test/java/com/pkb/common/config/SpringBootConfigStorageIntegrationTest.java create mode 100644 spring-boot-infrastructure/src/test/java/com/pkb/common/config/SpringBootConfigStorageTest.java create mode 100644 spring-boot-infrastructure/src/test/resources/application.properties diff --git a/config/src/main/java/com/pkb/common/config/AbstractMutableConfigStorage.java b/config/src/main/java/com/pkb/common/config/AbstractMutableConfigStorage.java new file mode 100644 index 00000000..7f4458ec --- /dev/null +++ b/config/src/main/java/com/pkb/common/config/AbstractMutableConfigStorage.java @@ -0,0 +1,14 @@ +package com.pkb.common.config; + +public abstract class AbstractMutableConfigStorage extends AbstractBaseConfigStorage { + + @Override + public void setValue(String key, String value) { + if (!MUTABLE_CONFIG_KEY.equals(key)) { + setValueInternal(key, value); + } + } + + abstract void setValueInternal(String key, String value); + +} diff --git a/config/src/main/java/com/pkb/common/config/ConfigStorage.java b/config/src/main/java/com/pkb/common/config/ConfigStorage.java index e8cd73ac..c9519e59 100644 --- a/config/src/main/java/com/pkb/common/config/ConfigStorage.java +++ b/config/src/main/java/com/pkb/common/config/ConfigStorage.java @@ -20,7 +20,9 @@ public interface ConfigStorage { Long getLong(String key, long defaultValue); - boolean isMutableConfigEnabled(); + default boolean isMutableConfigEnabled() { + return getBoolean(MUTABLE_CONFIG_KEY, false); + } void setValue(String key, String value); @@ -28,5 +30,4 @@ public interface ConfigStorage { void reset(); - ImmutableConfigStorage getImmutableConfig(); } diff --git a/config/src/main/java/com/pkb/common/config/ConfigStorageFactory.java b/config/src/main/java/com/pkb/common/config/ConfigStorageFactory.java index 9832703b..5304f647 100644 --- a/config/src/main/java/com/pkb/common/config/ConfigStorageFactory.java +++ b/config/src/main/java/com/pkb/common/config/ConfigStorageFactory.java @@ -10,7 +10,7 @@ public static ConfigStorage getConfigStorage() { } - public static ConfigStorage getConfigStorage(ImmutableConfigStorage baseStorage) { + public static ConfigStorage getConfigStorage(ConfigStorage baseStorage) { if (baseStorage.isMutableConfigEnabled()) { return new MutableRawConfigStorage(baseStorage); } diff --git a/config/src/main/java/com/pkb/common/config/ImmutableConfigStorage.java b/config/src/main/java/com/pkb/common/config/ImmutableConfigStorage.java deleted file mode 100644 index 637e046e..00000000 --- a/config/src/main/java/com/pkb/common/config/ImmutableConfigStorage.java +++ /dev/null @@ -1,30 +0,0 @@ -package com.pkb.common.config; - -public interface ImmutableConfigStorage extends ConfigStorage { - - @Override - default ImmutableConfigStorage getImmutableConfig() { - return this; - } - - @Override - default boolean isMutableConfigEnabled() { - return getBoolean(MUTABLE_CONFIG_KEY, false); - } - - @Override - default void setValue(String key, String value) { - /* no-op */ - } - - @Override - default OverrideRemovalResult removeOverrideAtKey(String key) { - return OverrideRemovalResult.NO_OP_AS_CONFIG_IS_IMMUTABLE; - } - - @Override - default void reset() { - /* no-op */ - } - -} diff --git a/config/src/main/java/com/pkb/common/config/ImmutableRawConfigStorage.java b/config/src/main/java/com/pkb/common/config/ImmutableRawConfigStorage.java index bed247c7..a3ccb9e5 100644 --- a/config/src/main/java/com/pkb/common/config/ImmutableRawConfigStorage.java +++ b/config/src/main/java/com/pkb/common/config/ImmutableRawConfigStorage.java @@ -1,12 +1,12 @@ package com.pkb.common.config; -import java.util.HashMap; -import java.util.Map; - import static java.util.Collections.emptyMap; import static java.util.Collections.unmodifiableMap; -public final class ImmutableRawConfigStorage extends AbstractBaseConfigStorage implements ImmutableConfigStorage { +import java.util.HashMap; +import java.util.Map; + +public final class ImmutableRawConfigStorage extends AbstractBaseConfigStorage { public static final ImmutableRawConfigStorage EMPTY = new ImmutableRawConfigStorage(emptyMap()); @@ -36,4 +36,19 @@ public String getString(String key, String defaultValue) { return storage.getOrDefault(key, defaultValue); } + @Override + public void setValue(String key, String value) { + //No-op + } + + @Override + public OverrideRemovalResult removeOverrideAtKey(String key) { + return OverrideRemovalResult.NO_OP_AS_CONFIG_IS_IMMUTABLE; + } + + @Override + public void reset() { + //No-op + } + } diff --git a/config/src/main/java/com/pkb/common/config/MutableConfigStorage.java b/config/src/main/java/com/pkb/common/config/MutableConfigStorage.java deleted file mode 100644 index c8030d79..00000000 --- a/config/src/main/java/com/pkb/common/config/MutableConfigStorage.java +++ /dev/null @@ -1,10 +0,0 @@ -package com.pkb.common.config; - -public interface MutableConfigStorage extends ConfigStorage { - - @Override - default boolean isMutableConfigEnabled() { - return true; - } - -} diff --git a/config/src/main/java/com/pkb/common/config/MutableRawConfigStorage.java b/config/src/main/java/com/pkb/common/config/MutableRawConfigStorage.java index 07d7a9cd..21271117 100644 --- a/config/src/main/java/com/pkb/common/config/MutableRawConfigStorage.java +++ b/config/src/main/java/com/pkb/common/config/MutableRawConfigStorage.java @@ -4,12 +4,12 @@ import java.util.Map; import java.util.function.Supplier; -public final class MutableRawConfigStorage extends AbstractBaseConfigStorage implements MutableConfigStorage { +public final class MutableRawConfigStorage extends AbstractMutableConfigStorage { private final Map overrideMap = new HashMap<>(); - private final ImmutableConfigStorage configStorage; + private final ConfigStorage configStorage; - MutableRawConfigStorage(ImmutableConfigStorage configStorage) { + MutableRawConfigStorage(ConfigStorage configStorage) { this.configStorage = configStorage; } @@ -24,10 +24,8 @@ public String getString(String key, String defaultValue) { } @Override - public void setValue(String key, String value) { - if (!MUTABLE_CONFIG_KEY.equals(key)) { - overrideMap.put(key, value); - } + void setValueInternal(String key, String value) { + overrideMap.put(key, value); } @Override @@ -45,15 +43,15 @@ public void reset() { overrideMap.clear(); } - @Override - public ImmutableConfigStorage getImmutableConfig() { - return configStorage; - } - private String getOverriddenOrOriginalValue(String key, Supplier originalSupplier) { if (overrideMap.containsKey(key)) { return overrideMap.get(key); } return originalSupplier.get(); } + + @Override + public boolean isMutableConfigEnabled() { + return true; + } } diff --git a/config/src/test/java/com/pkb/common/config/ImmutableRawConfigStorageTest.java b/config/src/test/java/com/pkb/common/config/ImmutableRawConfigStorageTest.java index d909f723..c270cba5 100644 --- a/config/src/test/java/com/pkb/common/config/ImmutableRawConfigStorageTest.java +++ b/config/src/test/java/com/pkb/common/config/ImmutableRawConfigStorageTest.java @@ -4,7 +4,6 @@ import static com.github.karsaig.approvalcrest.jupiter.MatcherAssert.assertThrows; import static com.github.karsaig.approvalcrest.jupiter.matcher.Matchers.sameJsonAsApproved; import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.sameInstance; import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.HashMap; @@ -197,9 +196,4 @@ public void removingNonExistentKey() { assertEquals(OverrideRemovalResult.NO_OP_AS_CONFIG_IS_IMMUTABLE, removalResult); } - @Test - void getImmutableConfigReturnsSelf() { - ConfigStorage configStorage = underTest.getImmutableConfig(); - assertThat(configStorage, sameInstance(underTest)); - } } diff --git a/config/src/test/java/com/pkb/common/config/MutableRawConfigStorageTest.java b/config/src/test/java/com/pkb/common/config/MutableRawConfigStorageTest.java index 094ff1ab..087d2f71 100644 --- a/config/src/test/java/com/pkb/common/config/MutableRawConfigStorageTest.java +++ b/config/src/test/java/com/pkb/common/config/MutableRawConfigStorageTest.java @@ -4,7 +4,6 @@ import static com.github.karsaig.approvalcrest.jupiter.MatcherAssert.assertThrows; import static com.github.karsaig.approvalcrest.jupiter.matcher.Matchers.sameJsonAsApproved; import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.sameInstance; import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.HashMap; @@ -195,11 +194,6 @@ void mutableConfigCannotBeOverridden() { assertThat(underTest.isMutableConfigEnabled(), is(true)); } - @Test - void getImmutableConfigReturnsOriginalImmutableConfig() { - ConfigStorage configStorage = underTest.getImmutableConfig(); - assertThat(configStorage, sameInstance(immutableRawConfigStorage)); - } @DisplayName("getInt returns original value without override") @Test diff --git a/pom.xml b/pom.xml index 1fec326f..ac36d7a7 100644 --- a/pom.xml +++ b/pom.xml @@ -56,6 +56,7 @@ 20-789c720-63866 Hoxton.SR8 5.3.15.Final + 2.3.5.RELEASE @@ -254,17 +255,22 @@ spring-context ${spring.version} - org.springframework - spring-test + spring-beans ${spring.version} - compile + + + org.springframework.boot + spring-boot-test + ${spring.boot.version} + test org.springframework - spring-beans + spring-test ${spring.version} + test diff --git a/spring-boot-infrastructure/pom.xml b/spring-boot-infrastructure/pom.xml index 6c964cfe..0041334c 100644 --- a/spring-boot-infrastructure/pom.xml +++ b/spring-boot-infrastructure/pom.xml @@ -14,27 +14,22 @@ org.springframework - spring-test - compile + spring-beans - org.springframework - spring-beans + org.springframework.boot + spring-boot-starter + ${spring.boot.version} + test org.springframework.cloud - spring-cloud-context - - - org.springframework.security - spring-security-crypto - - + spring-cloud-starter + test - org.junit.jupiter - junit-jupiter-api - compile + org.springframework.cloud + spring-cloud-context com.pkb.pkbcommon @@ -44,6 +39,30 @@ org.springframework spring-context + + com.github.karsaig + approvalcrest-junit-jupiter + + + org.hamcrest + hamcrest + + + org.mockito + mockito-core + + + org.mockito + mockito-junit-jupiter + + + org.springframework.boot + spring-boot-test + + + org.springframework + spring-test + \ No newline at end of file diff --git a/spring-boot-infrastructure/src/main/java/com/pkb/common/config/ConfigurationPropertiesScopingPostProcessor.java b/spring-boot-infrastructure/src/main/java/com/pkb/common/config/ConfigurationPropertiesScopingPostProcessor.java index 46a8c1af..a7ed3159 100644 --- a/spring-boot-infrastructure/src/main/java/com/pkb/common/config/ConfigurationPropertiesScopingPostProcessor.java +++ b/spring-boot-infrastructure/src/main/java/com/pkb/common/config/ConfigurationPropertiesScopingPostProcessor.java @@ -1,21 +1,22 @@ package com.pkb.common.config; +import java.util.Optional; + +import javax.annotation.ParametersAreNonnullByDefault; + import org.springframework.aop.scope.ScopedProxyUtils; import org.springframework.beans.BeansException; import org.springframework.beans.factory.config.BeanDefinition; import org.springframework.beans.factory.config.BeanDefinitionHolder; import org.springframework.beans.factory.config.ConfigurableListableBeanFactory; -import org.springframework.beans.factory.config.Scope; import org.springframework.beans.factory.support.BeanDefinitionRegistry; import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor; import org.springframework.beans.factory.support.GenericBeanDefinition; +import org.springframework.context.annotation.Scope; import org.springframework.context.annotation.ScopedProxyMode; import org.springframework.core.annotation.AnnotationAttributes; import org.springframework.core.type.AnnotationMetadata; -import javax.annotation.ParametersAreNonnullByDefault; -import java.util.Optional; - /** * This post-processor works around a bug/limitation of Spring Boot/Spring Cloud whereby * beans discovered by the @EnableConfigurationProperties or @ConfigurationPropertiesScan annotations @@ -31,13 +32,17 @@ @ParametersAreNonnullByDefault public class ConfigurationPropertiesScopingPostProcessor implements BeanDefinitionRegistryPostProcessor { + private static final String SCOPE_ANNOTATION = Scope.class.getName(); + @Override public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException { for (String name : registry.getBeanDefinitionNames()) { BeanDefinition beanDefinition = registry.getBeanDefinition(name); if (beanDefinition.getClass().getName().equals("org.springframework.boot.context.properties.ConfigurationPropertiesValueObjectBeanDefinition")) { GenericBeanDefinition gbd = (GenericBeanDefinition) beanDefinition; - Optional annAttrs = Optional.ofNullable(AnnotationAttributes.fromMap(AnnotationMetadata.introspect(gbd.getBeanClass()).getAnnotationAttributes(Scope.class.getName(), false))); + Optional annAttrs = Optional + .ofNullable(AnnotationAttributes.fromMap(AnnotationMetadata.introspect(gbd.getBeanClass()).getAnnotationAttributes( + SCOPE_ANNOTATION, false))); ScopedProxyMode scopedProxyMode = annAttrs.map(attrs -> attrs.getEnum("proxyMode")).orElse(ScopedProxyMode.NO); gbd.setScope(annAttrs.map(attrs -> attrs.getString("value")).orElse(gbd.getScope())); if (scopedProxyMode == ScopedProxyMode.NO) { diff --git a/spring-boot-infrastructure/src/main/java/com/pkb/common/config/SpringBootConfigStorage.java b/spring-boot-infrastructure/src/main/java/com/pkb/common/config/SpringBootConfigStorage.java index 37a650c6..59a2ec3a 100644 --- a/spring-boot-infrastructure/src/main/java/com/pkb/common/config/SpringBootConfigStorage.java +++ b/spring-boot-infrastructure/src/main/java/com/pkb/common/config/SpringBootConfigStorage.java @@ -1,12 +1,14 @@ package com.pkb.common.config; +import java.util.LinkedHashMap; +import java.util.Map; + +import javax.annotation.ParametersAreNonnullByDefault; + import org.springframework.cloud.context.scope.refresh.RefreshScope; import org.springframework.core.env.ConfigurableEnvironment; import org.springframework.core.env.MapPropertySource; -import javax.annotation.ParametersAreNonnullByDefault; -import java.util.LinkedHashMap; -import java.util.Map; /** * This class provides an implementation of the PKB ConfigStorage interface that interacts @@ -43,7 +45,7 @@ * infrastructure that may have been wired together according to their values - are dynamically updated. */ @ParametersAreNonnullByDefault -public class SpringBootConfigStorage extends AbstractBaseConfigStorage implements ImmutableConfigStorage { +public class SpringBootConfigStorage extends AbstractMutableConfigStorage { private final ConfigurableEnvironment environment; private final RefreshScope refreshScope; private final Map overrides = new LinkedHashMap<>(); @@ -66,12 +68,7 @@ public String getString(String key, String defaultValue) { } @Override - public boolean isMutableConfigEnabled() { - return getBoolean("mutableConfig.enabled", false); - } - - @Override - public void setValue(String key, String value) { + public void setValueInternal(String key, String value) { if (isMutableConfigEnabled()) { overrides.put(key, value); refreshScope.refreshAll(); @@ -99,4 +96,3 @@ public void reset() { } } - diff --git a/spring-boot-infrastructure/src/main/java/com/pkb/common/testing/IntegrationTest.java b/spring-boot-infrastructure/src/main/java/com/pkb/common/testing/IntegrationTest.java deleted file mode 100644 index fa015a92..00000000 --- a/spring-boot-infrastructure/src/main/java/com/pkb/common/testing/IntegrationTest.java +++ /dev/null @@ -1,28 +0,0 @@ -package com.pkb.common.testing; - -import java.lang.annotation.Documented; -import java.lang.annotation.ElementType; -import java.lang.annotation.Inherited; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -import org.junit.jupiter.api.Tag; -import org.springframework.test.context.ActiveProfiles; - -/** - * This tag helps organise integration tests for spring boot applications. - * When applied to a junit 5 test, it enables it to be filtered in maven - * using "groups" in the surefire/failsafe configuration. - * - * In addition, it applies the spring profile "integration-test" allowing - * selective configuration overrides. - */ -@Target(ElementType.TYPE) -@Retention(RetentionPolicy.RUNTIME) -@Inherited -@ActiveProfiles("integration-test") -@Documented -@Tag("integration-test") -public @interface IntegrationTest { -} diff --git a/spring-boot-infrastructure/src/test/java/com/pkb/common/config/SpringBootConfigStorageIntegrationTest.java b/spring-boot-infrastructure/src/test/java/com/pkb/common/config/SpringBootConfigStorageIntegrationTest.java new file mode 100644 index 00000000..0296b2ad --- /dev/null +++ b/spring-boot-infrastructure/src/test/java/com/pkb/common/config/SpringBootConfigStorageIntegrationTest.java @@ -0,0 +1,80 @@ +package com.pkb.common.config; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.equalTo; + +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.autoconfigure.EnableAutoConfiguration; +import org.springframework.boot.context.properties.ConfigurationProperties; +import org.springframework.boot.context.properties.ConstructorBinding; +import org.springframework.boot.context.properties.EnableConfigurationProperties; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.cloud.context.scope.refresh.RefreshScope; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.core.annotation.Order; +import org.springframework.core.env.ConfigurableEnvironment; + +import com.pkb.common.config.SpringBootConfigStorageIntegrationTest.TestConfiguration.TestConfigProperties; + +@SpringBootTest +public class SpringBootConfigStorageIntegrationTest { + + @Configuration + @EnableConfigurationProperties(TestConfigProperties.class) + @EnableAutoConfiguration + public static class TestConfiguration { + @Bean + @Order + public static ConfigurationPropertiesScopingPostProcessor configurationPropertiesScopingPostProcessor() { + return new ConfigurationPropertiesScopingPostProcessor(); + } + + @Bean + public SpringBootConfigStorage configStorage(ConfigurableEnvironment environment, RefreshScope refreshScope) { + return new SpringBootConfigStorage(environment, refreshScope); + } + + @ConfigurationProperties(prefix = "com.pkb.common.config") + @ConstructorBinding + @org.springframework.cloud.context.config.annotation.RefreshScope + public static class TestConfigProperties { + private final int testVal; + + public TestConfigProperties(int testVal) { + this.testVal = testVal; + } + + public int getTestVal() { + return testVal; + } + } + } + + @Autowired + private SpringBootConfigStorage configStorage; + + @Autowired + TestConfigProperties props; + + @Test + void returnsValueFromAppProperties() { + assertThat(props.getTestVal(), equalTo(10)); + } + + @Test + void overridesCorrectly() { + configStorage.setValue("com.pkb.common.config.test-val", "50"); + assertThat(props.getTestVal(), equalTo(50)); + } + + @Test + void resetsCorrectly() { + configStorage.setValue("com.pkb.common.config.test-val", "50"); + configStorage.reset(); + assertThat(props.getTestVal(), equalTo(10)); + + } + +} diff --git a/spring-boot-infrastructure/src/test/java/com/pkb/common/config/SpringBootConfigStorageTest.java b/spring-boot-infrastructure/src/test/java/com/pkb/common/config/SpringBootConfigStorageTest.java new file mode 100644 index 00000000..ecee2fdd --- /dev/null +++ b/spring-boot-infrastructure/src/test/java/com/pkb/common/config/SpringBootConfigStorageTest.java @@ -0,0 +1,94 @@ +package com.pkb.common.config; + +import static com.github.karsaig.approvalcrest.jupiter.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.equalTo; + +import java.util.HashMap; +import java.util.Map; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.springframework.cloud.context.scope.refresh.RefreshScope; +import org.springframework.core.env.MapPropertySource; +import org.springframework.core.env.StandardEnvironment; + +@ExtendWith(MockitoExtension.class) +class SpringBootConfigStorageTest { + + private final Map lowPriorityProperties = new HashMap<>(); + + private final StandardEnvironment environment = new StandardEnvironment(); + + @Mock + private RefreshScope refreshScope; + + private SpringBootConfigStorage underTest; + + @BeforeEach + void setup() { + underTest = new SpringBootConfigStorage(environment, refreshScope); + environment.getPropertySources().addLast(new MapPropertySource("standardProperties", lowPriorityProperties)); + } + + @Test + void cantOverrideMutableConfigProperty() { + assertThat(underTest.isMutableConfigEnabled(), equalTo(false)); + underTest.setValue(ConfigStorage.MUTABLE_CONFIG_KEY, "true"); + assertThat(underTest.getBoolean(ConfigStorage.MUTABLE_CONFIG_KEY, false), equalTo(false)); + assertThat(underTest.isMutableConfigEnabled(), equalTo(false)); + } + + @Test + void returnsOverrideForNormalProperty() { + lowPriorityProperties.put(ConfigStorage.MUTABLE_CONFIG_KEY, "true"); + lowPriorityProperties.put("myProp", "myVal"); + assertThat(underTest.getString("myProp"), equalTo("myVal")); + + underTest.setValue("myProp", "myOverrideValue"); + assertThat(underTest.getString("myProp"), equalTo("myOverrideValue")); + } + + @Test + void fallsBackToDefaultForNonExistentProperty() { + assertThat(underTest.getString("myProp", "myVal"), equalTo("myVal")); + } + + @Test + void resetsOverrideForPropertyCorrectly() { + lowPriorityProperties.put(ConfigStorage.MUTABLE_CONFIG_KEY, "true"); + lowPriorityProperties.put("myProp", "myVal"); + underTest.setValue("myProp", "myOverrideValue"); + underTest.reset(); + assertThat(underTest.getString("myProp"), equalTo("myVal")); + } + + @Test + void removesOverrideForPropertyCorrectly() { + lowPriorityProperties.put(ConfigStorage.MUTABLE_CONFIG_KEY, "true"); + lowPriorityProperties.put("myProp", "myVal"); + underTest.setValue("myProp", "myOverrideValue"); + assertThat(underTest.removeOverrideAtKey("myProp"), equalTo(OverrideRemovalResult.REMOVED)); + assertThat(underTest.getString("myProp"), equalTo("myVal")); + } + + @Test + void failsToRemoveNonExistentOverride() { + lowPriorityProperties.put(ConfigStorage.MUTABLE_CONFIG_KEY, "true"); + lowPriorityProperties.put("myProp", "myVal"); + underTest.setValue("myProp", "myOverrideValue"); + assertThat(underTest.removeOverrideAtKey("myProp2"), equalTo(OverrideRemovalResult.KEY_NOT_FOUND)); + assertThat(underTest.getString("myProp"), equalTo("myOverrideValue")); + } + + @Test + void skipsOverrideRemovalForNonMutableConfig() { + lowPriorityProperties.put("myProp", "myVal"); + underTest.setValue("myProp", "myOverrideValue"); + assertThat(underTest.removeOverrideAtKey("myProp2"), equalTo(OverrideRemovalResult.NO_OP_AS_CONFIG_IS_IMMUTABLE)); + assertThat(underTest.getString("myProp"), equalTo("myVal")); + } + +} diff --git a/spring-boot-infrastructure/src/test/resources/application.properties b/spring-boot-infrastructure/src/test/resources/application.properties new file mode 100644 index 00000000..68d5c440 --- /dev/null +++ b/spring-boot-infrastructure/src/test/resources/application.properties @@ -0,0 +1,2 @@ +com.pkb.common.config.test-val=10 +mutableConfig.enabled=true \ No newline at end of file