From dcfb7eb186c04d5f23df55976e6d416d60e6ef38 Mon Sep 17 00:00:00 2001 From: John Blum Date: Thu, 14 May 2020 22:32:31 -0700 Subject: [PATCH] Add configuration property to enable/disable data imports. --- .../AbstractCacheDataImporterExporter.java | 38 +- ...actCacheDataImporterExporterUnitTests.java | 362 +++++++++++++----- 2 files changed, 305 insertions(+), 95 deletions(-) diff --git a/spring-geode/src/main/java/org/springframework/geode/data/AbstractCacheDataImporterExporter.java b/spring-geode/src/main/java/org/springframework/geode/data/AbstractCacheDataImporterExporter.java index 8d7ecd3e..48876238 100644 --- a/spring-geode/src/main/java/org/springframework/geode/data/AbstractCacheDataImporterExporter.java +++ b/spring-geode/src/main/java/org/springframework/geode/data/AbstractCacheDataImporterExporter.java @@ -61,6 +61,7 @@ public abstract class AbstractCacheDataImporterExporter implements ApplicationContextAware, CacheDataImporterExporter, EnvironmentAware { protected static final boolean DEFAULT_CACHE_DATA_EXPORT_ENABLED = false; + protected static final boolean DEFAULT_CACHE_DATA_IMPORT_ENABLED = true; protected static final String CACHE_DATA_EXPORT_ENABLED_PROPERTY_NAME = "spring.boot.data.gemfire.cache.data.export.enabled"; @@ -68,6 +69,9 @@ public abstract class AbstractCacheDataImporterExporter protected static final String CACHE_DATA_IMPORT_ACTIVE_PROFILES_PROPERTY_NAME = "spring.boot.data.gemfire.cache.data.import.active-profiles"; + protected static final String CACHE_DATA_IMPORT_ENABLED_PROPERTY_NAME = + "spring.boot.data.gemfire.cache.data.import.enabled"; + protected static final String DEFAULT_CACHE_DATA_IMPORT_ACTIVE_PROFILES = ""; private static final String RESERVED_DEFAULT_PROFILE_NAME = "default"; @@ -199,12 +203,27 @@ public abstract class AbstractCacheDataImporterExporter .orElseGet(this::newRegionPredicate); } + /** + * Null-safe method to determine whether export has been explicitly configured and enabled or disabled. + * + * @param environment {@link Environment} used to assess the configuration of export. + * @return a boolean value indicating whether the export is enabled ({@literal true}) + * or disabled ({@literal false}); {@literal false} by default. + * @see org.springframework.core.env.Environment + */ + protected boolean isExportEnabled(@Nullable Environment environment) { + return environment != null && Boolean.TRUE.equals(environment + .getProperty(CACHE_DATA_EXPORT_ENABLED_PROPERTY_NAME, Boolean.class, DEFAULT_CACHE_DATA_EXPORT_ENABLED)); + } + /** * Exports data contained in the given {@link Region}. * * @param region {@link Region} to export data from. * @return the given {@link Region}. * @see org.apache.geode.cache.Region + * @see #isExportEnabled(Environment) + * @see #getRegionPredicate() */ @NonNull @Override public Region exportFrom(@NonNull Region region) { @@ -212,9 +231,8 @@ public abstract class AbstractCacheDataImporterExporter Assert.notNull(region, "Region must not be null"); boolean exportEnabled = getEnvironment() + .filter(this::isExportEnabled) .filter(environment -> getRegionPredicate().test(region)) - .filter(environment -> environment.getProperty(CACHE_DATA_EXPORT_ENABLED_PROPERTY_NAME, Boolean.class, - DEFAULT_CACHE_DATA_EXPORT_ENABLED)) .isPresent(); return exportEnabled ? doExportFrom(region) : region; @@ -229,12 +247,27 @@ public abstract class AbstractCacheDataImporterExporter */ protected abstract @NonNull Region doExportFrom(@NonNull Region region); + /** + * Null-safe method to determine whether import has been explicitly configured and enabled or disabled. + * + * @param environment {@link Environment} used to assess the configuration of the import. + * @return a boolean value indicating whether the import is enabled ({@literal true}) + * or disabled ({@literal false}). + * @see org.springframework.core.env.Environment + */ + protected boolean isImportEnabled(@Nullable Environment environment) { + return environment != null && Boolean.TRUE.equals(environment + .getProperty(CACHE_DATA_IMPORT_ENABLED_PROPERTY_NAME, Boolean.class, DEFAULT_CACHE_DATA_IMPORT_ENABLED)); + } + /** * Imports data into the given {@link Region}. * * @param region {@link Region} to import data into. * @return the given {@link Region}. * @see org.apache.geode.cache.Region + * @see #isImportEnabled(Environment) + * @see #getRegionPredicate() */ @NonNull @Override public Region importInto(@NonNull Region region) { @@ -242,6 +275,7 @@ public abstract class AbstractCacheDataImporterExporter Assert.notNull(region, "Region must not be null"); boolean importEnabled = getEnvironment() + .filter(this::isImportEnabled) .filter(environment -> getRegionPredicate().test(region)) .map(Environment::getActiveProfiles) .map(CollectionUtils::asSet) diff --git a/spring-geode/src/test/java/org/springframework/geode/data/AbstractCacheDataImporterExporterUnitTests.java b/spring-geode/src/test/java/org/springframework/geode/data/AbstractCacheDataImporterExporterUnitTests.java index 0a7dbbaa..8feadcd2 100644 --- a/spring-geode/src/test/java/org/springframework/geode/data/AbstractCacheDataImporterExporterUnitTests.java +++ b/spring-geode/src/test/java/org/springframework/geode/data/AbstractCacheDataImporterExporterUnitTests.java @@ -41,11 +41,13 @@ import org.apache.geode.cache.Region; import org.springframework.context.ApplicationContext; import org.springframework.core.env.Environment; +import org.springframework.data.gemfire.util.ArrayUtils; /** * Unit Tests for {@link AbstractCacheDataImporterExporter}. * * @author John Blum + * @see java.util.function.Predicate * @see org.junit.Test * @see org.mockito.Mockito * @see org.apache.geode.cache.Region @@ -64,6 +66,8 @@ public class AbstractCacheDataImporterExporterUnitTests { doCallRealMethod().when(importerExporter).importInto(any()); doCallRealMethod().when(importerExporter).getLogger(); doCallRealMethod().when(importerExporter).getRegionPredicate(); + doCallRealMethod().when(importerExporter).isExportEnabled(any()); + doCallRealMethod().when(importerExporter).isImportEnabled(any()); return importerExporter; } @@ -184,6 +188,49 @@ public class AbstractCacheDataImporterExporterUnitTests { } } + @Test + public void isExportEnabledReturnsTrueWhenExportIsEnabled() { + + Environment mockEnvironment = mock(Environment.class); + + doReturn(true).when(mockEnvironment) + .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_EXPORT_ENABLED_PROPERTY_NAME), + eq(Boolean.class), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_EXPORT_ENABLED)); + + AbstractCacheDataImporterExporter importerExporter = mockAbstractCacheDataImporterExporter(); + + assertThat(importerExporter.isExportEnabled(mockEnvironment)).isTrue(); + + verify(mockEnvironment, times(1)) + .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_EXPORT_ENABLED_PROPERTY_NAME), + eq(Boolean.class), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_EXPORT_ENABLED)); + verifyNoMoreInteractions(mockEnvironment); + } + + @Test + public void isExportEnabledReturnsFalseWhenExportIsDisabled() { + + Environment mockEnvironment = mock(Environment.class); + + doReturn(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_EXPORT_ENABLED).when(mockEnvironment) + .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_EXPORT_ENABLED_PROPERTY_NAME), + eq(Boolean.class), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_EXPORT_ENABLED)); + + AbstractCacheDataImporterExporter importerExporter = mockAbstractCacheDataImporterExporter(); + + assertThat(importerExporter.isExportEnabled(mockEnvironment)).isFalse(); + + verify(mockEnvironment, times(1)) + .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_EXPORT_ENABLED_PROPERTY_NAME), + eq(Boolean.class), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_EXPORT_ENABLED)); + verifyNoMoreInteractions(mockEnvironment); + } + + @Test + public void isExportEnabledReturnsFalseWhenEnvironmentIsNull() { + assertThat(mockAbstractCacheDataImporterExporter().isExportEnabled(null)).isFalse(); + } + @Test @SuppressWarnings("unchecked") public void exportFromWhenEnvironmentIsPresentPropertyIsTrueAndPredicateSaysYes() { @@ -253,6 +300,7 @@ public class AbstractCacheDataImporterExporterUnitTests { assertThat(importerExporter.exportFrom(mockRegion)).isEqualTo(mockRegion); verify(importerExporter, times(1)).getEnvironment(); + verify(importerExporter, never()).getRegionPredicate(); verify(importerExporter, never()).doExportFrom(any(Region.class)); verify(mockEnvironment, times(1)) .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_EXPORT_ENABLED_PROPERTY_NAME), @@ -273,12 +321,14 @@ public class AbstractCacheDataImporterExporterUnitTests { AbstractCacheDataImporterExporter importerExporter = mockAbstractCacheDataImporterExporter(); doReturn(Optional.of(mockEnvironment)).when(importerExporter).getEnvironment(); + doReturn(true).when(importerExporter).isExportEnabled(eq(mockEnvironment)); doReturn(mockPredicate).when(importerExporter).getRegionPredicate(); doReturn(false).when(mockPredicate).test(any()); assertThat(importerExporter.exportFrom(mockRegion)).isEqualTo(mockRegion); verify(importerExporter, times(1)).getEnvironment(); + verify(importerExporter, times(1)).isExportEnabled(eq(mockEnvironment)); verify(importerExporter, times(1)).getRegionPredicate(); verify(importerExporter, never()).doExportFrom(any(Region.class)); verify(mockPredicate, times(1)).test(eq(mockRegion)); @@ -315,6 +365,7 @@ public class AbstractCacheDataImporterExporterUnitTests { doCallRealMethod().when(importerExporter).containsAny(any(Collection.class), any(Collection.class)); doCallRealMethod().when(importerExporter).getDefaultProfilesIfEmpty(any(Set.class)); doCallRealMethod().when(importerExporter).getRegionPredicate(); + doCallRealMethod().when(importerExporter).isImportEnabled(any()); doCallRealMethod().when(importerExporter).isImportEnabled(any(Set.class), anyString()); doCallRealMethod().when(importerExporter).isNonDefaultProfileSet(any(Set.class)); doCallRealMethod().when(importerExporter).isNotSet(anyString()); @@ -322,9 +373,92 @@ public class AbstractCacheDataImporterExporterUnitTests { return importerExporter; } + private Environment configureImport(Environment mockEnvironment, boolean enabled) { + + doReturn(enabled).when(mockEnvironment) + .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ENABLED_PROPERTY_NAME), + eq(Boolean.class), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ENABLED)); + + return mockEnvironment; + } + + private Environment disableImport(Environment mockEnvironment) { + return configureImport(mockEnvironment, false); + } + + private Environment enableImport(Environment mockEnvironment) { + return configureImport(mockEnvironment, true); + } + + private Environment withEnvironmentActiveProfiles(Environment mockEnvironment, + String... environmentActiveProfiles) { + + doReturn(ArrayUtils.nullSafeArray(environmentActiveProfiles, String.class)) + .when(mockEnvironment).getActiveProfiles(); + + return mockEnvironment; + } + + private Environment withEnvironmentDefaultProfiles(Environment mockEnvironment, + String... environmentDefaultProfiles) { + + doReturn(ArrayUtils.nullSafeArray(environmentDefaultProfiles, String.class)) + .when(mockEnvironment).getDefaultProfiles(); + + return mockEnvironment; + } + + private Environment withImportActiveProfiles(Environment mockEnvironment, String importActiveProfiles) { + + doReturn(importActiveProfiles).when(mockEnvironment) + .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ACTIVE_PROFILES_PROPERTY_NAME), + eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ACTIVE_PROFILES)); + + return mockEnvironment; + } + + @Test + public void isImportEnabledReturnsTrueWhenImportIsEnabled() { + + Environment mockEnvironment = mock(Environment.class); + + doReturn(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ENABLED).when(mockEnvironment) + .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ENABLED_PROPERTY_NAME), + eq(Boolean.class), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ENABLED)); + + assertThat(mockAbstractCacheDataImporterExporter().isImportEnabled(mockEnvironment)).isTrue(); + + verify(mockEnvironment, times(1)) + .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ENABLED_PROPERTY_NAME), + eq(Boolean.class), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ENABLED)); + verifyNoMoreInteractions(mockEnvironment); + } + + @Test + public void isImportEnabledReturnsFalseWhenImportIsDisabled() { + + Environment mockEnvironment = mock(Environment.class); + + doReturn(false).when(mockEnvironment) + .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ENABLED_PROPERTY_NAME), + eq(Boolean.class), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ENABLED)); + + assertThat(mockAbstractCacheDataImporterExporter().isImportEnabled(mockEnvironment)).isFalse(); + + verify(mockEnvironment, times(1)) + .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ENABLED_PROPERTY_NAME), + eq(Boolean.class), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ENABLED)); + verifyNoMoreInteractions(mockEnvironment); + } + + @Test + public void isImportEnabledReturnsFalseWhenEnvironmentIsNull() { + assertThat(mockAbstractCacheDataImporterExporter().isImportEnabled(null)).isFalse(); + } + @Test @SuppressWarnings("unchecked") - public void importIntoWhenEnvironmentIsPresentActiveProfilesAreSetAndMatchAndPredicateSaysYes() { + public void importIntoWhenEnvironmentIsPresentImportIsEnabledPredicateSaysYesAndActiveProfilesMatchCallsDoImportInto() { Region mockRegion = mock(Region.class); @@ -334,10 +468,12 @@ public class AbstractCacheDataImporterExporterUnitTests { Environment mockEnvironment = mock(Environment.class); - when(mockEnvironment.getActiveProfiles()).thenReturn(new String[] { "TEST" }); - when(mockEnvironment.getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ACTIVE_PROFILES_PROPERTY_NAME), - eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ACTIVE_PROFILES))) - .thenReturn(" DEV , TEST"); + doReturn(new String[] { "TEST" }).when(mockEnvironment).getActiveProfiles(); + doReturn(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ENABLED).when(mockEnvironment) + .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ENABLED_PROPERTY_NAME), + eq(Boolean.class), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ENABLED)); + doReturn(" DEV , TEST").when(mockEnvironment).getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ACTIVE_PROFILES_PROPERTY_NAME), + eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ACTIVE_PROFILES)); AbstractCacheDataImporterExporter importerExporter = callRealMethodsFor(mock(AbstractCacheDataImporterExporter.class)); @@ -355,6 +491,9 @@ public class AbstractCacheDataImporterExporterUnitTests { .isImportEnabled(eq(Collections.singleton("TEST")), eq(" DEV , TEST")); verify(importerExporter, times(1)).doImportInto(eq(mockRegion)); verify(mockEnvironment, times(1)).getActiveProfiles(); + verify(mockEnvironment, times(1)) + .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ENABLED_PROPERTY_NAME), + eq(Boolean.class), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ENABLED)); verify(mockEnvironment, times(1)) .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ACTIVE_PROFILES_PROPERTY_NAME), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ACTIVE_PROFILES)); @@ -364,7 +503,7 @@ public class AbstractCacheDataImporterExporterUnitTests { @Test @SuppressWarnings("unchecked") - public void importIntoWhenEnvironmentIsNullWillNotCallDoImportInto() { + public void importIntoWhenEnvironmentIsNull() { Region mockRegion = mock(Region.class); @@ -375,6 +514,7 @@ public class AbstractCacheDataImporterExporterUnitTests { verify(importerExporter, times(1)).getEnvironment(); verify(importerExporter, never()).requireEnvironment(); + verify(importerExporter, never()).isImportEnabled(any(Environment.class)); verify(importerExporter, never()).isImportEnabled(any(Set.class), anyString()); verify(importerExporter, never()).doImportInto(eq(mockRegion)); verifyNoInteractions(mockRegion); @@ -382,11 +522,11 @@ public class AbstractCacheDataImporterExporterUnitTests { @Test @SuppressWarnings("unchecked") - public void importIntoWhenEnvironmentActiveProfilesIsNullWillNotCallDoImportInto() { + public void importIntoWhenImportIsDisabled() { Region mockRegion = mock(Region.class); - Environment mockEnvironment = mock(Environment.class); + Environment mockEnvironment = disableImport(mock(Environment.class)); AbstractCacheDataImporterExporter importerExporter = callRealMethodsFor(mock(AbstractCacheDataImporterExporter.class)); @@ -396,10 +536,104 @@ public class AbstractCacheDataImporterExporterUnitTests { assertThat(importerExporter.importInto(mockRegion)).isEqualTo(mockRegion); verify(importerExporter, times(1)).getEnvironment(); - verify(importerExporter, never()).requireEnvironment(); - verify(importerExporter, never()).isImportEnabled(any(Set.class), anyString()); + verify(importerExporter, times(1)).isImportEnabled(eq(mockEnvironment)); + verify(importerExporter, never()).doImportInto(any()); + verify(mockEnvironment, times(1)) + .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ENABLED_PROPERTY_NAME), + eq(Boolean.class), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ENABLED)); + verifyNoMoreInteractions(mockEnvironment); + verifyNoInteractions(mockRegion); + } + + @Test + @SuppressWarnings("unchecked") + public void importIntoWhenPredicateSaysNo() { + + Region mockRegion = mock(Region.class); + + Predicate> mockPredicate = mock(Predicate.class); + + doReturn(false).when(mockPredicate).test(any()); + + Environment mockEnvironment = enableImport(mock(Environment.class)); + + AbstractCacheDataImporterExporter importerExporter = + callRealMethodsFor(mock(AbstractCacheDataImporterExporter.class)); + + doReturn(Optional.of(mockEnvironment)).when(importerExporter).getEnvironment(); + doReturn(mockPredicate).when(importerExporter).getRegionPredicate(); + + assertThat(importerExporter.importInto(mockRegion)).isEqualTo(mockRegion); + + verify(importerExporter, times(1)).getEnvironment(); + verify(importerExporter, times(1)).isImportEnabled(eq(mockEnvironment)); + verify(importerExporter, times(1)).getRegionPredicate(); + verify(importerExporter, never()).doImportInto(any(Region.class)); + verify(mockEnvironment, times(1)) + .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ENABLED_PROPERTY_NAME), + eq(Boolean.class), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ENABLED)); + verify(mockPredicate, times(1)).test(eq(mockRegion)); + verifyNoMoreInteractions(mockEnvironment, mockPredicate); + verifyNoInteractions(mockRegion); + } + + @Test + @SuppressWarnings("unchecked") + public void importIntoWhenEnvironmentActiveProfilesAreNull() { + + Region mockRegion = mock(Region.class); + + Environment mockEnvironment = enableImport(mock(Environment.class)); + + AbstractCacheDataImporterExporter importerExporter = + callRealMethodsFor(mock(AbstractCacheDataImporterExporter.class)); + + doReturn(Optional.of(mockEnvironment)).when(importerExporter).getEnvironment(); + + assertThat(importerExporter.importInto(mockRegion)).isEqualTo(mockRegion); + + verify(importerExporter, times(1)).getEnvironment(); + verify(importerExporter, times(1)).isImportEnabled(eq(mockEnvironment)); + verify(importerExporter, times(1)).getRegionPredicate(); verify(importerExporter, never()).doImportInto(eq(mockRegion)); verify(mockEnvironment, times(1)).getActiveProfiles(); + verify(mockEnvironment, times(1)) + .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ENABLED_PROPERTY_NAME), + eq(Boolean.class), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ENABLED)); + verifyNoMoreInteractions(mockEnvironment); + verifyNoInteractions(mockRegion); + } + + @Test + @SuppressWarnings("unchecked") + public void importIntoWhenImportActiveProfilesAreNotSetCallsDoImportInto() { + + Region mockRegion = mock(Region.class); + + Environment mockEnvironment = withImportActiveProfiles(withEnvironmentActiveProfiles( + enableImport(mock(Environment.class)), "PROD"), " "); + + AbstractCacheDataImporterExporter importerExporter = + callRealMethodsFor(mock(AbstractCacheDataImporterExporter.class)); + + doReturn(mockRegion).when(importerExporter).doImportInto(eq(mockRegion)); + doReturn(Optional.of(mockEnvironment)).when(importerExporter).getEnvironment(); + doReturn(mockEnvironment).when(importerExporter).requireEnvironment(); + + assertThat(importerExporter.importInto(mockRegion)).isEqualTo(mockRegion); + + verify(importerExporter, times(1)).getEnvironment(); + verify(importerExporter, times(1)).requireEnvironment(); + verify(importerExporter, times(1)) + .isImportEnabled(eq(Collections.singleton("PROD")), eq(" ")); + verify(importerExporter, times(1)).doImportInto(eq(mockRegion)); + verify(mockEnvironment, times(1)).getActiveProfiles(); + verify(mockEnvironment, times(1)) + .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ENABLED_PROPERTY_NAME), + eq(Boolean.class), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ENABLED)); + verify(mockEnvironment, times(1)) + .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ACTIVE_PROFILES_PROPERTY_NAME), + eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ACTIVE_PROFILES)); verifyNoMoreInteractions(mockEnvironment); verifyNoInteractions(mockRegion); } @@ -410,11 +644,10 @@ public class AbstractCacheDataImporterExporterUnitTests { Region mockRegion = mock(Region.class); - Environment mockEnvironment = mock(Environment.class); + Environment mockEnvironment = + withImportActiveProfiles(enableImport(mock(Environment.class)), "DEV,TEST"); - when(mockEnvironment.getActiveProfiles()).thenReturn(new String[0]).thenReturn(new String[] { "PROD" }); - when(mockEnvironment.getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ACTIVE_PROFILES_PROPERTY_NAME), - eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ACTIVE_PROFILES))).thenReturn("DEV,TEST"); + doReturn(new String[0]).doReturn(new String[] { "PROD" }).when(mockEnvironment).getActiveProfiles(); AbstractCacheDataImporterExporter importerExporter = callRealMethodsFor(mock(AbstractCacheDataImporterExporter.class)); @@ -435,69 +668,9 @@ public class AbstractCacheDataImporterExporterUnitTests { verify(mockEnvironment, times(2)).getActiveProfiles(); verify(mockEnvironment, times(1)).getDefaultProfiles(); verify(mockEnvironment, times(2)) - .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ACTIVE_PROFILES_PROPERTY_NAME), - eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ACTIVE_PROFILES)); - verifyNoMoreInteractions(mockEnvironment); - verifyNoInteractions(mockRegion); - } - - @Test - @SuppressWarnings("unchecked") - public void importIntoWhenPredicateSaysNo() { - - Region mockRegion = mock(Region.class); - - Predicate> mockPredicate = mock(Predicate.class); - - doReturn(false).when(mockPredicate).test(any()); - - Environment mockEnvironment = mock(Environment.class); - - AbstractCacheDataImporterExporter importerExporter = - callRealMethodsFor(mock(AbstractCacheDataImporterExporter.class)); - - doReturn(Optional.of(mockEnvironment)).when(importerExporter).getEnvironment(); - doReturn(mockPredicate).when(importerExporter).getRegionPredicate(); - - assertThat(importerExporter.importInto(mockRegion)).isEqualTo(mockRegion); - - verify(importerExporter, times(1)).getEnvironment(); - verify(importerExporter, times(1)).getRegionPredicate(); - verify(importerExporter, never()).doImportInto(any(Region.class)); - verify(mockPredicate, times(1)).test(eq(mockRegion)); - verifyNoInteractions(mockEnvironment); - verifyNoInteractions(mockRegion); - } - - @Test - @SuppressWarnings("unchecked") - public void importIntoWhenImportActiveProfilesAreNotSetCallsDoImportInto() { - - Region mockRegion = mock(Region.class); - - Environment mockEnvironment = mock(Environment.class); - - when(mockEnvironment.getActiveProfiles()).thenReturn(new String[] { "PROD" }); - when(mockEnvironment.getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ACTIVE_PROFILES_PROPERTY_NAME), - eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ACTIVE_PROFILES))) - .thenReturn(" "); - - AbstractCacheDataImporterExporter importerExporter = - callRealMethodsFor(mock(AbstractCacheDataImporterExporter.class)); - - doReturn(mockRegion).when(importerExporter).doImportInto(eq(mockRegion)); - doReturn(Optional.of(mockEnvironment)).when(importerExporter).getEnvironment(); - doReturn(mockEnvironment).when(importerExporter).requireEnvironment(); - - assertThat(importerExporter.importInto(mockRegion)).isEqualTo(mockRegion); - - verify(importerExporter, times(1)).getEnvironment(); - verify(importerExporter, times(1)).requireEnvironment(); - verify(importerExporter, times(1)) - .isImportEnabled(eq(Collections.singleton("PROD")), eq(" ")); - verify(importerExporter, times(1)).doImportInto(eq(mockRegion)); - verify(mockEnvironment, times(1)).getActiveProfiles(); - verify(mockEnvironment, times(1)) + .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ENABLED_PROPERTY_NAME), + eq(Boolean.class), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ENABLED)); + verify(mockEnvironment, times(2)) .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ACTIVE_PROFILES_PROPERTY_NAME), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ACTIVE_PROFILES)); verifyNoMoreInteractions(mockEnvironment); @@ -510,12 +683,11 @@ public class AbstractCacheDataImporterExporterUnitTests { Region mockRegion = mock(Region.class); - Environment mockEnvironment = mock(Environment.class); + Environment mockEnvironment = withImportActiveProfiles(withEnvironmentActiveProfiles( + enableImport(mock(Environment.class))), "DEV,TEST"); - when(mockEnvironment.getActiveProfiles()).thenReturn(new String[0]); - when(mockEnvironment.getDefaultProfiles()).thenReturn(new String[] { "PROD" }).thenReturn(new String[] { "default" }); - when(mockEnvironment.getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ACTIVE_PROFILES_PROPERTY_NAME), - eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ACTIVE_PROFILES))).thenReturn("DEV,TEST"); + doReturn(new String[] { "PROD" }).doReturn(new String[] { "default" }) + .when(mockEnvironment).getDefaultProfiles(); AbstractCacheDataImporterExporter importerExporter = callRealMethodsFor(mock(AbstractCacheDataImporterExporter.class)); @@ -535,6 +707,9 @@ public class AbstractCacheDataImporterExporterUnitTests { verify(importerExporter, never()).doImportInto(any(Region.class)); verify(mockEnvironment, times(2)).getActiveProfiles(); verify(mockEnvironment, times(2)).getDefaultProfiles(); + verify(mockEnvironment, times(2)) + .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ENABLED_PROPERTY_NAME), + eq(Boolean.class), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ENABLED)); verify(mockEnvironment, times(2)) .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ACTIVE_PROFILES_PROPERTY_NAME), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ACTIVE_PROFILES)); @@ -548,12 +723,11 @@ public class AbstractCacheDataImporterExporterUnitTests { Region mockRegion = mock(Region.class); - Environment mockEnvironment = mock(Environment.class); + Environment mockEnvironment = withImportActiveProfiles(withEnvironmentDefaultProfiles( + enableImport(mock(Environment.class)), "DEV", "TEST"), + "DEV,TEST"); - when(mockEnvironment.getActiveProfiles()).thenReturn(null).thenReturn(new String[] { "PROD" }); - when(mockEnvironment.getDefaultProfiles()).thenReturn(new String[] { "DEV", "TEST" }); - when(mockEnvironment.getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ACTIVE_PROFILES_PROPERTY_NAME), - eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ACTIVE_PROFILES))).thenReturn("DEV,TEST"); + doReturn(null).doReturn(new String[] { "PROD" }).when(mockEnvironment).getActiveProfiles(); AbstractCacheDataImporterExporter importerExporter = callRealMethodsFor(mock(AbstractCacheDataImporterExporter.class)); @@ -573,6 +747,9 @@ public class AbstractCacheDataImporterExporterUnitTests { verify(importerExporter, never()).doImportInto(any(Region.class)); verify(mockEnvironment, times(2)).getActiveProfiles(); verify(mockEnvironment, never()).getDefaultProfiles(); + verify(mockEnvironment, times(2)) + .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ENABLED_PROPERTY_NAME), + eq(Boolean.class), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ENABLED)); verify(mockEnvironment, times(1)) .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ACTIVE_PROFILES_PROPERTY_NAME), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ACTIVE_PROFILES)); @@ -586,12 +763,8 @@ public class AbstractCacheDataImporterExporterUnitTests { Region mockRegion = mock(Region.class); - Environment mockEnvironment = mock(Environment.class); - - when(mockEnvironment.getActiveProfiles()).thenReturn(new String[0]); - when(mockEnvironment.getDefaultProfiles()).thenReturn(new String[] { "TEST" }); - when(mockEnvironment.getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ACTIVE_PROFILES_PROPERTY_NAME), - eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ACTIVE_PROFILES))).thenReturn("DEV,TEST"); + Environment mockEnvironment = withImportActiveProfiles(withEnvironmentDefaultProfiles(withEnvironmentActiveProfiles( + enableImport(mock(Environment.class))), "TEST"), "DEV,TEST"); AbstractCacheDataImporterExporter importerExporter = callRealMethodsFor(mock(AbstractCacheDataImporterExporter.class)); @@ -609,6 +782,9 @@ public class AbstractCacheDataImporterExporterUnitTests { verify(importerExporter, times(1)).doImportInto(eq(mockRegion)); verify(mockEnvironment, times(1)).getActiveProfiles(); verify(mockEnvironment, times(1)).getDefaultProfiles(); + verify(mockEnvironment, times(1)) + .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ENABLED_PROPERTY_NAME), + eq(Boolean.class), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ENABLED)); verify(mockEnvironment, times(1)) .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ACTIVE_PROFILES_PROPERTY_NAME), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ACTIVE_PROFILES));