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 48876238..0db629bd 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 @@ -18,7 +18,6 @@ package org.springframework.geode.data; import static org.springframework.data.gemfire.util.RuntimeExceptionFactory.newIllegalStateException; import java.util.Arrays; -import java.util.Collection; import java.util.Collections; import java.util.Objects; import java.util.Optional; @@ -32,6 +31,7 @@ import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware; import org.springframework.context.EnvironmentAware; import org.springframework.core.env.Environment; +import org.springframework.core.io.ResourceLoader; import org.springframework.data.gemfire.util.ArrayUtils; import org.springframework.data.gemfire.util.CollectionUtils; import org.springframework.lang.NonNull; @@ -43,15 +43,17 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** - * Abstract base class implementing the {@link CacheDataExporter} and {@link CacheDataImporter} interface in order to - * simply import/export data operation implementations in a consistent way. + * Abstract base class implementing the {@link CacheDataExporter} and {@link CacheDataImporter} interfaces in order to + * simply import/export data access operation implementations in a consistent way. * * @author John Blum + * @see java.util.function.Predicate * @see org.apache.geode.cache.Region * @see org.springframework.context.ApplicationContext * @see org.springframework.context.ApplicationContextAware * @see org.springframework.context.EnvironmentAware * @see org.springframework.core.env.Environment + * @see org.springframework.core.io.ResourceLoader * @see org.springframework.geode.data.CacheDataExporter * @see org.springframework.geode.data.CacheDataImporter * @since 1.3.0 @@ -72,7 +74,11 @@ public abstract class AbstractCacheDataImporterExporter protected static final String CACHE_DATA_IMPORT_ENABLED_PROPERTY_NAME = "spring.boot.data.gemfire.cache.data.import.enabled"; + protected static final String CLASSPATH_RESOURCE_PREFIX = ResourceLoader.CLASSPATH_URL_PREFIX; protected static final String DEFAULT_CACHE_DATA_IMPORT_ACTIVE_PROFILES = ""; + protected static final String FILESYSTEM_RESOURCE_PREFIX = "file:"; + protected static final String RESOURCE_NAME_PATTERN = "data-%s.json"; + protected static final String RESOURCE_PATH_SEPARATOR = "/"; private static final String RESERVED_DEFAULT_PROFILE_NAME = "default"; @@ -212,8 +218,10 @@ public abstract class AbstractCacheDataImporterExporter * @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)); + + return environment != null + && Boolean.TRUE.equals(environment.getProperty(CACHE_DATA_EXPORT_ENABLED_PROPERTY_NAME, Boolean.class, + DEFAULT_CACHE_DATA_EXPORT_ENABLED)); } /** @@ -256,8 +264,10 @@ public abstract class AbstractCacheDataImporterExporter * @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)); + + return environment != null + && Boolean.TRUE.equals(environment.getProperty(CACHE_DATA_IMPORT_ENABLED_PROPERTY_NAME, Boolean.class, + DEFAULT_CACHE_DATA_IMPORT_ENABLED)); } /** @@ -277,18 +287,7 @@ public abstract class AbstractCacheDataImporterExporter boolean importEnabled = getEnvironment() .filter(this::isImportEnabled) .filter(environment -> getRegionPredicate().test(region)) - .map(Environment::getActiveProfiles) - .map(CollectionUtils::asSet) - .map(this::getDefaultProfilesIfEmpty) - .filter(activeProfiles -> { - - String cacheDataImportActiveProfiles = requireEnvironment() - .getProperty(CACHE_DATA_IMPORT_ACTIVE_PROFILES_PROPERTY_NAME, - DEFAULT_CACHE_DATA_IMPORT_ACTIVE_PROFILES); - - return isImportEnabled(activeProfiles, cacheDataImportActiveProfiles); - - }) + .filter(this::isImportProfilesActive) .isPresent(); return importEnabled ? doImportInto(region) : region; @@ -303,16 +302,75 @@ public abstract class AbstractCacheDataImporterExporter */ protected abstract @NonNull Region doImportInto(@NonNull Region region); - @Nullable Set getDefaultProfilesIfEmpty(@Nullable Set activeProfiles) { + /** + * Determines whether the Cache Data Import data access operation is enabled based on the configured, active/default + * {@literal Profiles} as declared in the Spring {@link Environment}. + * + * @param environment {@link Environment} used to evaluate the configured, active {@literal Profiles}; + * must not be {@literal null}. + * @return a boolean value indicating whether the the Cache Data Import data access operation is enabled based on + * the configured, active/default {@literal Profiles}. + * @throws IllegalArgumentException if {@link Environment} is {@literal null}. + * @see org.springframework.core.env.Environment + * @see #useDefaultProfilesIfEmpty(Environment, Set) + * @see #getActiveProfiles(Environment) + */ + protected boolean isImportProfilesActive(@NonNull Environment environment) { - Set resolvedProfiles = activeProfiles; + Assert.notNull(environment, "Environment must not be null"); - if (CollectionUtils.nullSafeSet(activeProfiles).isEmpty()) { + boolean importProfilesActive = true; - Set defaultProfiles = - CollectionUtils.asSet(ArrayUtils.nullSafeArray(requireEnvironment().getDefaultProfiles(), String.class)); + String cacheDataImportActiveProfiles = + environment.getProperty(CACHE_DATA_IMPORT_ACTIVE_PROFILES_PROPERTY_NAME, + DEFAULT_CACHE_DATA_IMPORT_ACTIVE_PROFILES); - if (isNonDefaultProfileSet(defaultProfiles)) { + Set cacheDataImportProfiles = commaDelimitedStringToSet(cacheDataImportActiveProfiles); + + if (!cacheDataImportProfiles.isEmpty()) { + + Set configuredProfiles = useDefaultProfilesIfEmpty(environment, getActiveProfiles(environment)); + + // The configured, "Active Profiles" must contain at least 1 of the configured cacheDataImportProfiles. + importProfilesActive = CollectionUtils.containsAny(configuredProfiles, cacheDataImportProfiles); + } + + return importProfilesActive; + } + + @NonNull Set commaDelimitedStringToSet(@Nullable String commaDelimitedString) { + + return StringUtils.hasText(commaDelimitedString) + ? Arrays.stream(commaDelimitedString.split(",")) + .map(String::trim) + .filter(StringUtils::hasText) + .collect(Collectors.toSet()) + : Collections.emptySet(); + } + + @NonNull Set getActiveProfiles(@NonNull Environment environment) { + + return environment != null + ? toSet(environment.getActiveProfiles(), String.class) + : Collections.emptySet(); + } + + @NonNull Set useDefaultProfilesIfEmpty(@NonNull Environment environment, + @Nullable Set activeProfiles) { + + Set resolvedProfiles = CollectionUtils.nullSafeSet(activeProfiles).stream() + .filter(StringUtils::hasText) + .collect(Collectors.toSet()); + + if (resolvedProfiles.isEmpty()) { + + Set defaultProfiles = environment != null + ? toSet(environment.getDefaultProfiles(), String.class).stream() + .filter(StringUtils::hasText) + .collect(Collectors.toSet()) + : Collections.emptySet(); + + if (isNotDefaultProfileOnlySet(defaultProfiles)) { resolvedProfiles = defaultProfiles; } } @@ -320,34 +378,15 @@ public abstract class AbstractCacheDataImporterExporter return resolvedProfiles; } - // The Set of Profiles cannot be null, empty or contain only the "default" Profile. - boolean isNonDefaultProfileSet(@Nullable Set profiles) { + // The Set of configured Profiles cannot be null, empty or contain only the "default" Profile. + boolean isNotDefaultProfileOnlySet(@Nullable Set profiles) { return Objects.nonNull(profiles) && !profiles.isEmpty() && !Collections.singleton(RESERVED_DEFAULT_PROFILE_NAME).containsAll(profiles); } - // Active Spring Profiles must contain at least 1 of the configured cacheDataImportActiveProfiles unless unset. - boolean isImportEnabled(Set activeProfiles, String cacheDataImportActiveProfiles) { - return isNotSet(cacheDataImportActiveProfiles) - || containsAny(activeProfiles, commaDelimitedListOfStringsToSet(cacheDataImportActiveProfiles)); - } - - Set commaDelimitedListOfStringsToSet(@NonNull String commaDelimitedListOfStrings) { - - return StringUtils.hasText(commaDelimitedListOfStrings) - ? Arrays.stream(commaDelimitedListOfStrings.split(",")) - .map(String::trim) - .collect(Collectors.toSet()) - : Collections.emptySet(); - } - - boolean containsAny(Collection source, Collection elements) { - return CollectionUtils.containsAny(source, elements); - } - - boolean isNotSet(String value) { - return !StringUtils.hasText((value)); + private static Set toSet(T[] array, Class type) { + return CollectionUtils.asSet(ArrayUtils.nullSafeArray(array, type)); } } diff --git a/spring-geode/src/main/java/org/springframework/geode/data/json/JsonCacheDataImporterExporter.java b/spring-geode/src/main/java/org/springframework/geode/data/json/JsonCacheDataImporterExporter.java index 4836df86..66d4d2c4 100644 --- a/spring-geode/src/main/java/org/springframework/geode/data/json/JsonCacheDataImporterExporter.java +++ b/spring-geode/src/main/java/org/springframework/geode/data/json/JsonCacheDataImporterExporter.java @@ -30,7 +30,6 @@ import org.apache.geode.pdx.PdxInstance; import org.springframework.core.io.ClassPathResource; import org.springframework.core.io.Resource; -import org.springframework.core.io.ResourceLoader; import org.springframework.dao.DataAccessResourceFailureException; import org.springframework.data.gemfire.util.CollectionUtils; import org.springframework.geode.data.AbstractCacheDataImporterExporter; @@ -79,15 +78,11 @@ public class JsonCacheDataImporterExporter extends AbstractCacheDataImporterExpo private static final int CONTENT_PREVIEW_LENGTH = 50; private static final int DEFAULT_BUFFER_SIZE = 32768; - protected static final String CLASSPATH_RESOURCE_PREFIX = ResourceLoader.CLASSPATH_URL_PREFIX; - protected static final String FILESYSTEM_RESOURCE_PREFIX = "file://"; - protected static final String RESOURCE_NAME_PATTERN = "data-%s.json"; - private JsonToPdxArrayConverter jsonToPdxArrayConverter = newJsonToPdxArrayConverter(); private final RegionValuesToJsonConverter regionValuesToJsonConverter = new RegionValuesToJsonConverter(); - // TODO configure via an SPI + // TODO configure via an SPI or DI private @NonNull JsonToPdxArrayConverter newJsonToPdxArrayConverter() { return new JacksonJsonToPdxConverter(); } @@ -252,7 +247,8 @@ public class JsonCacheDataImporterExporter extends AbstractCacheDataImporterExpo * @return a {@link String file system path} specifying the location for where to export the {@link Resource}. */ protected @NonNull String getResourceLocation() { - return String.format("%1$s%2$s%3$s", FILESYSTEM_RESOURCE_PREFIX, System.getProperty("user.dir"), File.separator); + return String.format("%1$s%2$s%2$s%3$s%4$s", FILESYSTEM_RESOURCE_PREFIX, RESOURCE_PATH_SEPARATOR, + System.getProperty("user.dir"), File.separator); } /** 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 8feadcd2..93462895 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 @@ -21,27 +21,25 @@ import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.doCallRealMethod; import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.inOrder; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.never; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verifyNoInteractions; import static org.mockito.Mockito.verifyNoMoreInteractions; -import static org.mockito.Mockito.when; -import java.util.Collection; -import java.util.Collections; import java.util.Optional; import java.util.Set; import java.util.function.Predicate; import org.junit.Test; +import org.mockito.InOrder; 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}. @@ -62,15 +60,32 @@ public class AbstractCacheDataImporterExporterUnitTests { AbstractCacheDataImporterExporter importerExporter = mock(AbstractCacheDataImporterExporter.class); - doCallRealMethod().when(importerExporter).exportFrom(any()); - doCallRealMethod().when(importerExporter).importInto(any()); doCallRealMethod().when(importerExporter).getLogger(); - doCallRealMethod().when(importerExporter).getRegionPredicate(); doCallRealMethod().when(importerExporter).isExportEnabled(any()); doCallRealMethod().when(importerExporter).isImportEnabled(any()); + doCallRealMethod().when(importerExporter).exportFrom(any()); + doCallRealMethod().when(importerExporter).importInto(any()); return importerExporter; } + + private Environment configureExport(Environment mockEnvironment, boolean enabled) { + + doReturn(enabled).when(mockEnvironment) + .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_EXPORT_ENABLED_PROPERTY_NAME), + eq(Boolean.class), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_EXPORT_ENABLED)); + + return mockEnvironment; + } + + private Environment disableExport(Environment mockEnvironment) { + return configureExport(mockEnvironment, false); + } + + private Environment enableExport(Environment mockEnvironment) { + return configureExport(mockEnvironment, true); + } + @Test public void setAndGetApplicationContext() { @@ -87,6 +102,7 @@ public class AbstractCacheDataImporterExporterUnitTests { importerExporter.setApplicationContext(mockApplicationContext); assertThat(importerExporter.getApplicationContext().orElse(null)).isEqualTo(mockApplicationContext); + assertThat(importerExporter.requireApplicationContext()).isEqualTo(mockApplicationContext); importerExporter.setApplicationContext(null); @@ -108,6 +124,8 @@ public class AbstractCacheDataImporterExporterUnitTests { assertThat(importerExporter.getApplicationContext().orElse(null)).isEqualTo(mockApplicationContext); assertThat(importerExporter.requireApplicationContext()).isEqualTo(mockApplicationContext); + + verify(importerExporter, times(2)).getApplicationContext(); } @Test(expected = IllegalStateException.class) @@ -127,6 +145,9 @@ public class AbstractCacheDataImporterExporterUnitTests { throw expected; } + finally { + verify(importerExporter, times(1)).getApplicationContext(); + } } @Test @@ -136,9 +157,9 @@ public class AbstractCacheDataImporterExporterUnitTests { AbstractCacheDataImporterExporter importerExporter = mock(AbstractCacheDataImporterExporter.class); - doCallRealMethod().when(importerExporter).setEnvironment(any()); doCallRealMethod().when(importerExporter).getEnvironment(); doCallRealMethod().when(importerExporter).requireEnvironment(); + doCallRealMethod().when(importerExporter).setEnvironment(any()); assertThat(importerExporter.getEnvironment().orElse(null)).isNull(); @@ -160,13 +181,15 @@ public class AbstractCacheDataImporterExporterUnitTests { AbstractCacheDataImporterExporter importerExporter = mock(AbstractCacheDataImporterExporter.class); doCallRealMethod().when(importerExporter).getEnvironment(); - doCallRealMethod().when(importerExporter).setEnvironment(any()); doCallRealMethod().when(importerExporter).requireEnvironment(); + doCallRealMethod().when(importerExporter).setEnvironment(any()); importerExporter.setEnvironment(mockEnvironment); assertThat(importerExporter.getEnvironment().orElse(null)).isEqualTo(mockEnvironment); assertThat(importerExporter.requireEnvironment()).isEqualTo(mockEnvironment); + + verify(importerExporter, times(2)).getEnvironment(); } @Test(expected = IllegalStateException.class) @@ -186,16 +209,15 @@ public class AbstractCacheDataImporterExporterUnitTests { throw expected; } + finally { + verify(importerExporter, times(1)).getEnvironment(); + } } @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)); + Environment mockEnvironment = enableExport(mock(Environment.class)); AbstractCacheDataImporterExporter importerExporter = mockAbstractCacheDataImporterExporter(); @@ -204,17 +226,14 @@ public class AbstractCacheDataImporterExporterUnitTests { 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)); + Environment mockEnvironment = disableExport(mock(Environment.class)); AbstractCacheDataImporterExporter importerExporter = mockAbstractCacheDataImporterExporter(); @@ -223,23 +242,20 @@ public class AbstractCacheDataImporterExporterUnitTests { 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() { + public void isExportEnabledWhenEnvironmentIsNullIsNullSafeAndReturnsFalse() { assertThat(mockAbstractCacheDataImporterExporter().isExportEnabled(null)).isFalse(); } @Test @SuppressWarnings("unchecked") - public void exportFromWhenEnvironmentIsPresentPropertyIsTrueAndPredicateSaysYes() { + public void exportFromWhenEnvironmentIsPresentExportIsEnabledAndRegionPredicateSaysYesCallsDoExportFrom() { - Environment mockEnvironment = mock(Environment.class); - - when(mockEnvironment.getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_EXPORT_ENABLED_PROPERTY_NAME), - eq(Boolean.class), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_EXPORT_ENABLED))) - .thenReturn(true); + Environment mockEnvironment = enableExport(mock(Environment.class)); Predicate> mockPredicate = mock(Predicate.class); @@ -256,6 +272,8 @@ public class AbstractCacheDataImporterExporterUnitTests { 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, times(1)).doExportFrom(eq(mockRegion)); verify(mockEnvironment, times(1)) .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_EXPORT_ENABLED_PROPERTY_NAME), @@ -283,15 +301,11 @@ public class AbstractCacheDataImporterExporterUnitTests { @Test @SuppressWarnings("unchecked") - public void exportFromWhenEnvironmentPropertyIsNotSetWillNotCallDoExportFrom() { + public void exportFromWhenExportIsDisabledWillNotCallDoExportFrom() { Region mockRegion = mock(Region.class); - Environment mockEnvironment = mock(Environment.class); - - when(mockEnvironment.getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_EXPORT_ENABLED_PROPERTY_NAME), - eq(Boolean.class), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_EXPORT_ENABLED))) - .thenReturn(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_EXPORT_ENABLED); + Environment mockEnvironment = disableExport(mock(Environment.class)); AbstractCacheDataImporterExporter importerExporter = mockAbstractCacheDataImporterExporter(); @@ -300,6 +314,7 @@ public class AbstractCacheDataImporterExporterUnitTests { assertThat(importerExporter.exportFrom(mockRegion)).isEqualTo(mockRegion); verify(importerExporter, times(1)).getEnvironment(); + verify(importerExporter, times(1)).isExportEnabled(eq(mockEnvironment)); verify(importerExporter, never()).getRegionPredicate(); verify(importerExporter, never()).doExportFrom(any(Region.class)); verify(mockEnvironment, times(1)) @@ -310,9 +325,9 @@ public class AbstractCacheDataImporterExporterUnitTests { @Test @SuppressWarnings("unchecked") - public void exportFromWhenPredicateSaysNo() { + public void exportFromWhenRegionPredicateSaysNoWillNotCallDoExportFrom() { - Environment mockEnvironment = mock(Environment.class); + Environment mockEnvironment = enableExport(mock(Environment.class)); Predicate> mockPredicate = mock(Predicate.class); @@ -321,7 +336,6 @@ 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()); @@ -331,8 +345,10 @@ public class AbstractCacheDataImporterExporterUnitTests { verify(importerExporter, times(1)).isExportEnabled(eq(mockEnvironment)); verify(importerExporter, times(1)).getRegionPredicate(); verify(importerExporter, never()).doExportFrom(any(Region.class)); + verify(mockEnvironment, times(1)) + .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_EXPORT_ENABLED_PROPERTY_NAME), + eq(Boolean.class), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_EXPORT_ENABLED)); verify(mockPredicate, times(1)).test(eq(mockRegion)); - verifyNoInteractions(mockEnvironment); verifyNoInteractions(mockRegion); } @@ -360,15 +376,14 @@ public class AbstractCacheDataImporterExporterUnitTests { @SuppressWarnings("unchecked") private AbstractCacheDataImporterExporter callRealMethodsFor(AbstractCacheDataImporterExporter importerExporter) { - doCallRealMethod().when(importerExporter).importInto(any()); - doCallRealMethod().when(importerExporter).commaDelimitedListOfStringsToSet(anyString()); - doCallRealMethod().when(importerExporter).containsAny(any(Collection.class), any(Collection.class)); - doCallRealMethod().when(importerExporter).getDefaultProfilesIfEmpty(any(Set.class)); + doCallRealMethod().when(importerExporter).commaDelimitedStringToSet(anyString()); + doCallRealMethod().when(importerExporter).getActiveProfiles(any(Environment.class)); doCallRealMethod().when(importerExporter).getRegionPredicate(); + doCallRealMethod().when(importerExporter).importInto(any()); 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()); + doCallRealMethod().when(importerExporter).isImportProfilesActive(any()); + doCallRealMethod().when(importerExporter).isNotDefaultProfileOnlySet(any(Set.class)); + doCallRealMethod().when(importerExporter).useDefaultProfilesIfEmpty(any(Environment.class), any(Set.class)); return importerExporter; } @@ -390,20 +405,21 @@ public class AbstractCacheDataImporterExporterUnitTests { return configureImport(mockEnvironment, true); } - private Environment withEnvironmentActiveProfiles(Environment mockEnvironment, - String... environmentActiveProfiles) { + @SuppressWarnings("unchecked") + private T[] toArray(T... array) { + return array; + } - doReturn(ArrayUtils.nullSafeArray(environmentActiveProfiles, String.class)) - .when(mockEnvironment).getActiveProfiles(); + private Environment withEnvironmentActiveProfiles(Environment mockEnvironment, String... activeProfiles) { + + doReturn(activeProfiles).when(mockEnvironment).getActiveProfiles(); return mockEnvironment; } - private Environment withEnvironmentDefaultProfiles(Environment mockEnvironment, - String... environmentDefaultProfiles) { + private Environment withEnvironmentDefaultProfiles(Environment mockEnvironment, String... defaultProfiles) { - doReturn(ArrayUtils.nullSafeArray(environmentDefaultProfiles, String.class)) - .when(mockEnvironment).getDefaultProfiles(); + doReturn(defaultProfiles).when(mockEnvironment).getDefaultProfiles(); return mockEnvironment; } @@ -420,84 +436,77 @@ public class AbstractCacheDataImporterExporterUnitTests { @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)); + Environment mockEnvironment = enableImport(mock(Environment.class)); 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)); + Environment mockEnvironment = disableImport(mock(Environment.class)); 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() { + public void isImportEnabledWhenEnvironmentIsNullIsNullSafeAndReturnsFalse() { assertThat(mockAbstractCacheDataImporterExporter().isImportEnabled(null)).isFalse(); } @Test @SuppressWarnings("unchecked") - public void importIntoWhenEnvironmentIsPresentImportIsEnabledPredicateSaysYesAndActiveProfilesMatchCallsDoImportInto() { + public void importIntoWhenEnvironmentIsPresentImportIsEnabledRegionPredicateSaysYesAndActiveProfilesMatchCallsDoImportInto() { Region mockRegion = mock(Region.class); Predicate> mockPredicate = mock(Predicate.class); + Environment mockEnvironment = withImportActiveProfiles(withEnvironmentDefaultProfiles( + enableImport(mock(Environment.class)), "DEV"), "DEV, TEST"); + + AbstractCacheDataImporterExporter importer = callRealMethodsFor(mockAbstractCacheDataImporterExporter()); + + doReturn(Optional.of(mockEnvironment)).when(importer).getEnvironment(); + doReturn(toArray("TEST")).doReturn(toArray(" ")).when(mockEnvironment).getActiveProfiles(); + doReturn(mockPredicate).when(importer).getRegionPredicate(); doReturn(true).when(mockPredicate).test(eq(mockRegion)); + doReturn(mockRegion).when(importer).doImportInto(eq(mockRegion)); - Environment mockEnvironment = mock(Environment.class); + assertThat(importer.importInto(mockRegion)).isEqualTo(mockRegion); + assertThat(importer.importInto(mockRegion)).isEqualTo(mockRegion); - doReturn(new String[] { "TEST" }).when(mockEnvironment).getActiveProfiles(); - doReturn(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ENABLED).when(mockEnvironment) + verify(importer, times(2)).getEnvironment(); + verify(importer, times(2)).isImportEnabled(eq(mockEnvironment)); + verify(importer, times(2)).getRegionPredicate(); + verify(importer, times(2)).isImportProfilesActive(eq(mockEnvironment)); + verify(importer, times(2)).doImportInto(eq(mockRegion)); + + verify(mockEnvironment, times(2)).getActiveProfiles(); + verify(mockEnvironment, times(1)).getDefaultProfiles(); + verify(mockEnvironment, times(2)) .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)); - - doReturn(mockRegion).when(importerExporter).doImportInto(eq(mockRegion)); - doReturn(Optional.of(mockEnvironment)).when(importerExporter).getEnvironment(); - doReturn(mockPredicate).when(importerExporter).getRegionPredicate(); - 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("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)) + verify(mockEnvironment, times(2)) .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ACTIVE_PROFILES_PROPERTY_NAME), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ACTIVE_PROFILES)); - verify(mockPredicate, times(1)).test(eq(mockRegion)); + + verify(mockPredicate, times(2)).test(eq(mockRegion)); + + verifyNoMoreInteractions(mockEnvironment, mockPredicate); + verifyNoInteractions(mockRegion); } @@ -507,16 +516,15 @@ public class AbstractCacheDataImporterExporterUnitTests { Region mockRegion = mock(Region.class); - AbstractCacheDataImporterExporter importerExporter = - callRealMethodsFor(mock(AbstractCacheDataImporterExporter.class)); + AbstractCacheDataImporterExporter importer = callRealMethodsFor(mockAbstractCacheDataImporterExporter()); - assertThat(importerExporter.importInto(mockRegion)).isEqualTo(mockRegion); + assertThat(importer.importInto(mockRegion)).isEqualTo(mockRegion); - 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)); + verify(importer, times(1)).getEnvironment(); + verify(importer, never()).isImportEnabled(any()); + verify(importer, never()).getRegionPredicate(); + verify(importer, never()).isImportProfilesActive(any()); + verify(importer, never()).doImportInto(eq(mockRegion)); verifyNoInteractions(mockRegion); } @@ -528,16 +536,17 @@ public class AbstractCacheDataImporterExporterUnitTests { Environment mockEnvironment = disableImport(mock(Environment.class)); - AbstractCacheDataImporterExporter importerExporter = - callRealMethodsFor(mock(AbstractCacheDataImporterExporter.class)); + AbstractCacheDataImporterExporter importer = callRealMethodsFor(mockAbstractCacheDataImporterExporter()); - doReturn(Optional.of(mockEnvironment)).when(importerExporter).getEnvironment(); + doReturn(Optional.of(mockEnvironment)).when(importer).getEnvironment(); - assertThat(importerExporter.importInto(mockRegion)).isEqualTo(mockRegion); + assertThat(importer.importInto(mockRegion)).isEqualTo(mockRegion); - verify(importerExporter, times(1)).getEnvironment(); - verify(importerExporter, times(1)).isImportEnabled(eq(mockEnvironment)); - verify(importerExporter, never()).doImportInto(any()); + verify(importer, times(1)).getEnvironment(); + verify(importer, times(1)).isImportEnabled(eq(mockEnvironment)); + verify(importer, never()).getRegionPredicate(); + verify(importer, never()).isImportProfilesActive(any()); + verify(importer, 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)); @@ -547,59 +556,66 @@ public class AbstractCacheDataImporterExporterUnitTests { @Test @SuppressWarnings("unchecked") - public void importIntoWhenPredicateSaysNo() { + public void importIntoWhenRegionPredicateSaysNo() { Region mockRegion = mock(Region.class); Predicate> mockPredicate = mock(Predicate.class); + Environment mockEnvironment = mock(Environment.class); + + AbstractCacheDataImporterExporter importer = callRealMethodsFor(mockAbstractCacheDataImporterExporter()); + + doReturn(Optional.of(mockEnvironment)).when(importer).getEnvironment(); + doReturn(true).when(importer).isImportEnabled(eq(mockEnvironment)); + doReturn(mockPredicate).when(importer).getRegionPredicate(); doReturn(false).when(mockPredicate).test(any()); - Environment mockEnvironment = enableImport(mock(Environment.class)); + assertThat(importer.importInto(mockRegion)).isEqualTo(mockRegion); - 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(importer, times(1)).getEnvironment(); + verify(importer, times(1)).isImportEnabled(eq(mockEnvironment)); + verify(importer, times(1)).getRegionPredicate(); + verify(importer, never()).isImportProfilesActive(any()); + verify(importer, never()).doImportInto(any(Region.class)); verify(mockPredicate, times(1)).test(eq(mockRegion)); - verifyNoMoreInteractions(mockEnvironment, mockPredicate); - verifyNoInteractions(mockRegion); + verifyNoMoreInteractions(mockPredicate); + verifyNoInteractions(mockEnvironment, mockRegion); } @Test @SuppressWarnings("unchecked") - public void importIntoWhenEnvironmentActiveProfilesAreNull() { + public void importIntoWhenImportActiveProfilesAreSetAndEnvironmentActiveAndDefaultProfilesAreNotSet() { Region mockRegion = mock(Region.class); - Environment mockEnvironment = enableImport(mock(Environment.class)); + Predicate> mockPredicate = mock(Predicate.class); - AbstractCacheDataImporterExporter importerExporter = - callRealMethodsFor(mock(AbstractCacheDataImporterExporter.class)); + Environment mockEnvironment = + withImportActiveProfiles(enableImport(mock(Environment.class)), "DEV, TEST"); - doReturn(Optional.of(mockEnvironment)).when(importerExporter).getEnvironment(); + AbstractCacheDataImporterExporter importer = callRealMethodsFor(mockAbstractCacheDataImporterExporter()); - assertThat(importerExporter.importInto(mockRegion)).isEqualTo(mockRegion); + doReturn(Optional.of(mockEnvironment)).when(importer).getEnvironment(); + doReturn(mockPredicate).when(importer).getRegionPredicate(); + doReturn(true).when(mockPredicate).test(eq(mockRegion)); - verify(importerExporter, times(1)).getEnvironment(); - verify(importerExporter, times(1)).isImportEnabled(eq(mockEnvironment)); - verify(importerExporter, times(1)).getRegionPredicate(); - verify(importerExporter, never()).doImportInto(eq(mockRegion)); + assertThat(importer.importInto(mockRegion)).isEqualTo(mockRegion); + + verify(importer, times(1)).getEnvironment(); + verify(importer, times(1)).isImportEnabled(eq(mockEnvironment)); + verify(importer, times(1)).getRegionPredicate(); + verify(importer, times(1)).isImportProfilesActive(eq(mockEnvironment)); + verify(importer, never()).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)); + verify(mockPredicate, times(1)).test(eq(mockRegion)); verifyNoMoreInteractions(mockEnvironment); verifyNoInteractions(mockRegion); } @@ -610,31 +626,41 @@ public class AbstractCacheDataImporterExporterUnitTests { Region mockRegion = mock(Region.class); + Predicate> mockPredicate = mock(Predicate.class); + Environment mockEnvironment = withImportActiveProfiles(withEnvironmentActiveProfiles( enableImport(mock(Environment.class)), "PROD"), " "); - AbstractCacheDataImporterExporter importerExporter = - callRealMethodsFor(mock(AbstractCacheDataImporterExporter.class)); + AbstractCacheDataImporterExporter importer = callRealMethodsFor(mockAbstractCacheDataImporterExporter()); - doReturn(mockRegion).when(importerExporter).doImportInto(eq(mockRegion)); - doReturn(Optional.of(mockEnvironment)).when(importerExporter).getEnvironment(); - doReturn(mockEnvironment).when(importerExporter).requireEnvironment(); + doReturn(Optional.of(mockEnvironment)).when(importer).getEnvironment(); + doReturn(mockPredicate).when(importer).getRegionPredicate(); + doReturn(true).when(mockPredicate).test(eq(mockRegion)); + doReturn(mockRegion).when(importer).doImportInto(eq(mockRegion)); - assertThat(importerExporter.importInto(mockRegion)).isEqualTo(mockRegion); + assertThat(importer.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(); + InOrder order = inOrder(importer); + + order.verify(importer, times(1)).getEnvironment(); + order.verify(importer, times(1)).isImportEnabled(eq(mockEnvironment)); + order.verify(importer, times(1)).getRegionPredicate(); + order.verify(importer, times(1)).isImportProfilesActive(eq(mockEnvironment)); + order. verify(importer, times(1)).doImportInto(eq(mockRegion)); + + verify(mockEnvironment, never()).getActiveProfiles(); + verify(mockEnvironment, never()).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)); - verifyNoMoreInteractions(mockEnvironment); + + verify(mockPredicate, times(1)).test(eq(mockRegion)); + + verifyNoMoreInteractions(mockEnvironment, mockPredicate); + verifyNoInteractions(mockRegion); } @@ -644,27 +670,26 @@ public class AbstractCacheDataImporterExporterUnitTests { Region mockRegion = mock(Region.class); + Predicate> mockPredicate = mock(Predicate.class); + Environment mockEnvironment = withImportActiveProfiles(enableImport(mock(Environment.class)), "DEV,TEST"); - doReturn(new String[0]).doReturn(new String[] { "PROD" }).when(mockEnvironment).getActiveProfiles(); + AbstractCacheDataImporterExporter importer = callRealMethodsFor(mockAbstractCacheDataImporterExporter()); - AbstractCacheDataImporterExporter importerExporter = - callRealMethodsFor(mock(AbstractCacheDataImporterExporter.class)); + doReturn(Optional.of(mockEnvironment)).when(importer).getEnvironment(); + doReturn(new String[0]).doReturn(toArray("PROD")).when(mockEnvironment).getActiveProfiles(); + doReturn(mockPredicate).when(importer).getRegionPredicate(); + doReturn(true).when(mockPredicate).test(eq(mockRegion)); - doReturn(Optional.of(mockEnvironment)).when(importerExporter).getEnvironment(); - doReturn(mockEnvironment).when(importerExporter).requireEnvironment(); + assertThat(importer.importInto(mockRegion)).isEqualTo(mockRegion); + assertThat(importer.importInto(mockRegion)).isEqualTo(mockRegion); - assertThat(importerExporter.importInto(mockRegion)).isEqualTo(mockRegion); - assertThat(importerExporter.importInto(mockRegion)).isEqualTo(mockRegion); - - verify(importerExporter, times(2)).getEnvironment(); - verify(importerExporter, times(3)).requireEnvironment(); - verify(importerExporter, times(1)) - .isImportEnabled(eq(Collections.emptySet()), eq("DEV,TEST")); - verify(importerExporter, times(1)) - .isImportEnabled(eq(Collections.singleton("PROD")), eq("DEV,TEST")); - verify(importerExporter, never()).doImportInto(eq(mockRegion)); + verify(importer, times(2)).getEnvironment(); + verify(importer, times(2)).isImportEnabled(eq(mockEnvironment)); + verify(importer, times(2)).getRegionPredicate(); + verify(importer, times(2)).isImportProfilesActive(eq(mockEnvironment)); + verify(importer, never()).doImportInto(eq(mockRegion)); verify(mockEnvironment, times(2)).getActiveProfiles(); verify(mockEnvironment, times(1)).getDefaultProfiles(); verify(mockEnvironment, times(2)) @@ -673,7 +698,8 @@ public class AbstractCacheDataImporterExporterUnitTests { verify(mockEnvironment, times(2)) .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ACTIVE_PROFILES_PROPERTY_NAME), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ACTIVE_PROFILES)); - verifyNoMoreInteractions(mockEnvironment); + verify(mockPredicate, times(2)).test(eq(mockRegion)); + verifyNoMoreInteractions(mockEnvironment, mockPredicate); verifyNoInteractions(mockRegion); } @@ -683,28 +709,26 @@ public class AbstractCacheDataImporterExporterUnitTests { Region mockRegion = mock(Region.class); - Environment mockEnvironment = withImportActiveProfiles(withEnvironmentActiveProfiles( - enableImport(mock(Environment.class))), "DEV,TEST"); + Predicate> mockPredicate = mock(Predicate.class); - doReturn(new String[] { "PROD" }).doReturn(new String[] { "default" }) - .when(mockEnvironment).getDefaultProfiles(); + Environment mockEnvironment = + withImportActiveProfiles(enableImport(mock(Environment.class)), "DEV,TEST"); - AbstractCacheDataImporterExporter importerExporter = - callRealMethodsFor(mock(AbstractCacheDataImporterExporter.class)); + AbstractCacheDataImporterExporter importer = callRealMethodsFor(mockAbstractCacheDataImporterExporter()); - doReturn(Optional.of(mockEnvironment)).when(importerExporter).getEnvironment(); - doReturn(mockEnvironment).when(importerExporter).requireEnvironment(); + doReturn(Optional.of(mockEnvironment)).when(importer).getEnvironment(); + doReturn(toArray("PROD")).doReturn(toArray("default")).when(mockEnvironment).getDefaultProfiles(); + doReturn(mockPredicate).when(importer).getRegionPredicate(); + doReturn(true).when(mockPredicate).test(eq(mockRegion)); - assertThat(importerExporter.importInto(mockRegion)).isEqualTo(mockRegion); - assertThat(importerExporter.importInto(mockRegion)).isEqualTo(mockRegion); + assertThat(importer.importInto(mockRegion)).isEqualTo(mockRegion); + assertThat(importer.importInto(mockRegion)).isEqualTo(mockRegion); - verify(importerExporter, times(2)).getEnvironment(); - verify(importerExporter, times(4)).requireEnvironment(); - verify(importerExporter, times(1)) - .isImportEnabled(eq(Collections.singleton("PROD")), eq("DEV,TEST")); - verify(importerExporter, times(1)) - .isImportEnabled(eq(Collections.emptySet()), eq("DEV,TEST")); - verify(importerExporter, never()).doImportInto(any(Region.class)); + verify(importer, times(2)).getEnvironment(); + verify(importer, times(2)).isImportEnabled(eq(mockEnvironment)); + verify(importer, times(2)).getRegionPredicate(); + verify(importer, times(2)).isImportProfilesActive(eq(mockEnvironment)); + verify(importer, never()).doImportInto(any(Region.class)); verify(mockEnvironment, times(2)).getActiveProfiles(); verify(mockEnvironment, times(2)).getDefaultProfiles(); verify(mockEnvironment, times(2)) @@ -713,94 +737,56 @@ public class AbstractCacheDataImporterExporterUnitTests { verify(mockEnvironment, times(2)) .getProperty(eq(AbstractCacheDataImporterExporter.CACHE_DATA_IMPORT_ACTIVE_PROFILES_PROPERTY_NAME), eq(AbstractCacheDataImporterExporter.DEFAULT_CACHE_DATA_IMPORT_ACTIVE_PROFILES)); - verifyNoMoreInteractions(mockEnvironment); + verify(mockPredicate, times(2)).test(eq(mockRegion)); + verifyNoMoreInteractions(mockEnvironment, mockPredicate); verifyNoInteractions(mockRegion); } @Test @SuppressWarnings("unchecked") - public void importIntoWhenEnvironmentDefaultProfilesAndActiveProfilesConflictWillNotCallDoImportInto() { + public void importIntoWhenEnvironmentDefaultAndActiveProfilesConflictWillNotCallDoImportInto() { Region mockRegion = mock(Region.class); - Environment mockEnvironment = withImportActiveProfiles(withEnvironmentDefaultProfiles( - enableImport(mock(Environment.class)), "DEV", "TEST"), - "DEV,TEST"); - - doReturn(null).doReturn(new String[] { "PROD" }).when(mockEnvironment).getActiveProfiles(); - - AbstractCacheDataImporterExporter importerExporter = - callRealMethodsFor(mock(AbstractCacheDataImporterExporter.class)); - - doReturn(Optional.of(mockEnvironment)).when(importerExporter).getEnvironment(); - doReturn(mockEnvironment).when(importerExporter).requireEnvironment(); - - assertThat(importerExporter.importInto(mockRegion)).isEqualTo(mockRegion); - assertThat(importerExporter.importInto(mockRegion)).isEqualTo(mockRegion); - - verify(importerExporter, times(2)).getEnvironment(); - verify(importerExporter, times(1)).requireEnvironment(); - verify(importerExporter, times(1)) - .getDefaultProfilesIfEmpty(Collections.singleton("PROD")); - verify(importerExporter, times(1)) - .isImportEnabled(eq(Collections.singleton("PROD")), eq("DEV,TEST")); - 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)); - verifyNoMoreInteractions(mockEnvironment); - verifyNoInteractions(mockRegion); - } - - @Test - @SuppressWarnings("unchecked") - public void importIntoWhenEnvironmentActiveProfilesAreNotSetAndDefaultProfilesContainImportActiveProfilesCallsDoImportInto() { - - Region mockRegion = mock(Region.class); + Predicate> mockPredicate = mock(Predicate.class); Environment mockEnvironment = withImportActiveProfiles(withEnvironmentDefaultProfiles(withEnvironmentActiveProfiles( - enableImport(mock(Environment.class))), "TEST"), "DEV,TEST"); + enableImport(mock(Environment.class)), "PROD"), "DEV", "TEST"), + "DEV,TEST"); - AbstractCacheDataImporterExporter importerExporter = - callRealMethodsFor(mock(AbstractCacheDataImporterExporter.class)); + AbstractCacheDataImporterExporter importer = callRealMethodsFor(mockAbstractCacheDataImporterExporter()); - doReturn(mockRegion).when(importerExporter).doImportInto(eq(mockRegion)); - doReturn(Optional.of(mockEnvironment)).when(importerExporter).getEnvironment(); - doReturn(mockEnvironment).when(importerExporter).requireEnvironment(); + doReturn(Optional.of(mockEnvironment)).when(importer).getEnvironment(); + doReturn(mockPredicate).when(importer).getRegionPredicate(); + doReturn(true).when(mockPredicate).test(eq(mockRegion)); - assertThat(importerExporter.importInto(mockRegion)).isEqualTo(mockRegion); + assertThat(importer.importInto(mockRegion)).isEqualTo(mockRegion); - verify(importerExporter, times(1)).getEnvironment(); - verify(importerExporter, times(2)).requireEnvironment(); - verify(importerExporter, times(1)) - .isImportEnabled(eq(Collections.singleton("TEST")), eq("DEV,TEST")); - verify(importerExporter, times(1)).doImportInto(eq(mockRegion)); + verify(importer, times(1)).getEnvironment(); + verify(importer, times(1)).isImportEnabled(eq(mockEnvironment)); + verify(importer, times(1)).getRegionPredicate(); + verify(importer, times(1)).isImportProfilesActive(eq(mockEnvironment)); + verify(importer, never()).doImportInto(any(Region.class)); verify(mockEnvironment, times(1)).getActiveProfiles(); - verify(mockEnvironment, times(1)).getDefaultProfiles(); + verify(mockEnvironment, never()).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)); - verifyNoMoreInteractions(mockEnvironment); + verify(mockPredicate, times(1)).test(eq(mockRegion)); + verifyNoMoreInteractions(mockEnvironment, mockPredicate); verifyNoInteractions(mockRegion); } @Test(expected = IllegalArgumentException.class) public void importIntoNullRegionThrowsIllegalArgumentException() { - AbstractCacheDataImporterExporter importerExporter = mock(AbstractCacheDataImporterExporter.class); - - doCallRealMethod().when(importerExporter).importInto(any()); + AbstractCacheDataImporterExporter importer = mockAbstractCacheDataImporterExporter(); try { - importerExporter.importInto(null); + importer.importInto(null); } catch (IllegalArgumentException expected) { @@ -810,8 +796,8 @@ public class AbstractCacheDataImporterExporterUnitTests { throw expected; } finally { - verify(importerExporter, never()).getEnvironment(); - verify(importerExporter, never()).doImportInto(any(Region.class)); + verify(importer, never()).getEnvironment(); + verify(importer, never()).doImportInto(any(Region.class)); } } } diff --git a/spring-geode/src/test/java/org/springframework/geode/data/json/JsonCacheDataImporterExporterUnitTests.java b/spring-geode/src/test/java/org/springframework/geode/data/json/JsonCacheDataImporterExporterUnitTests.java index c57f6520..5dc743b6 100644 --- a/spring-geode/src/test/java/org/springframework/geode/data/json/JsonCacheDataImporterExporterUnitTests.java +++ b/spring-geode/src/test/java/org/springframework/geode/data/json/JsonCacheDataImporterExporterUnitTests.java @@ -89,8 +89,7 @@ public class JsonCacheDataImporterExporterUnitTests { doReturn("TestRegion").when(mockRegion).getName(); doReturn(Optional.of(mockResource)).when(this.importer).getResource(eq(mockRegion), anyString()); - doReturn(JsonCacheDataImporterExporter.FILESYSTEM_RESOURCE_PREFIX + "/path/to/data.json") - .when(importer).getResourceLocation(); + doReturn( "file:///path/to/data.json").when(importer).getResourceLocation(); doNothing().when(this.importer).save(anyString(), any(Resource.class)); doReturn(json).when(this.importer).toJson(any()); @@ -98,7 +97,7 @@ public class JsonCacheDataImporterExporterUnitTests { verify(this.importer, times(1)).toJson(eq(mockRegion)); verify(this.importer, times(1)).getResource(eq(mockRegion), - eq(JsonCacheDataImporterExporter.FILESYSTEM_RESOURCE_PREFIX + "/path/to/data.json")); + eq("file:///path/to/data.json")); verify(this.importer, times(1)).getResourceLocation(); verify(this.importer, times(1)).save(eq(json), eq(mockResource)); } @@ -219,8 +218,7 @@ public class JsonCacheDataImporterExporterUnitTests { byte[] json = "[{ \"name\": \"Jon Doe\"}, { \"name\": \"Jane Doe\" }]".getBytes(); - doReturn(Optional.of(mockResource)).when(this.importer).getResource(eq(mockRegion), - eq(JsonCacheDataImporterExporter.CLASSPATH_RESOURCE_PREFIX)); + doReturn(Optional.of(mockResource)).when(this.importer).getResource(eq(mockRegion),eq("classpath:")); doReturn(true).when(mockResource).exists(); doReturn(json).when(this.importer).getContent(eq(mockResource)); doReturn(ArrayUtils.asArray(mockPdxInstanceOne, mockPdxInstanceTwo)).when(this.importer).toPdx(eq(json)); @@ -229,8 +227,7 @@ public class JsonCacheDataImporterExporterUnitTests { assertThat(this.importer.doImportInto(mockRegion)).isEqualTo(mockRegion); - verify(this.importer, times(1)) - .getResource(eq(mockRegion), eq(JsonCacheDataImporterExporter.CLASSPATH_RESOURCE_PREFIX)); + verify(this.importer, times(1)).getResource(eq(mockRegion), eq("classpath:")); verify(this.importer, times(1)).getContent(eq(mockResource)); verify(this.importer, times(1)).toPdx(eq(json)); verify(this.importer, times(1)).resolveKey(eq(mockPdxInstanceOne)); @@ -250,14 +247,12 @@ public class JsonCacheDataImporterExporterUnitTests { Region mockRegion = mock(Region.class); - doReturn(Optional.empty()).when(this.importer) - .getResource(eq(mockRegion), eq(JsonCacheDataImporterExporter.CLASSPATH_RESOURCE_PREFIX)); + doReturn(Optional.empty()).when(this.importer).getResource(eq(mockRegion), eq("classpath:")); assertThat(this.importer.doImportInto(mockRegion)).isEqualTo(mockRegion); verify(this.importer, times(1)).doImportInto(eq(mockRegion)); - verify(this.importer, times(1)) - .getResource(eq(mockRegion), eq(JsonCacheDataImporterExporter.CLASSPATH_RESOURCE_PREFIX)); + verify(this.importer, times(1)).getResource(eq(mockRegion), eq("classpath:")); verifyNoMoreInteractions(this.importer); verifyNoInteractions(mockRegion); } @@ -270,15 +265,13 @@ public class JsonCacheDataImporterExporterUnitTests { Region mockRegion = mock(Region.class); - doReturn(Optional.of(mockResource)).when(this.importer) - .getResource(eq(mockRegion), eq(JsonCacheDataImporterExporter.CLASSPATH_RESOURCE_PREFIX)); + doReturn(Optional.of(mockResource)).when(this.importer).getResource(eq(mockRegion), eq("classpath:")); doReturn(false).when(mockResource).exists(); assertThat(this.importer.doImportInto(mockRegion)).isEqualTo(mockRegion); verify(this.importer, times(1)).doImportInto(eq(mockRegion)); - verify(this.importer, times(1)) - .getResource(eq(mockRegion), eq(JsonCacheDataImporterExporter.CLASSPATH_RESOURCE_PREFIX)); + verify(this.importer, times(1)).getResource(eq(mockRegion), eq("classpath:")); verify(mockResource, times(1)).exists(); verifyNoMoreInteractions(this.importer); verifyNoMoreInteractions(mockResource); @@ -293,16 +286,14 @@ public class JsonCacheDataImporterExporterUnitTests { Region mockRegion = mock(Region.class); - doReturn(Optional.of(mockResource)).when(this.importer) - .getResource(eq(mockRegion), eq(JsonCacheDataImporterExporter.CLASSPATH_RESOURCE_PREFIX)); + doReturn(Optional.of(mockResource)).when(this.importer).getResource(eq(mockRegion), eq("classpath:")); doReturn(true).when(mockResource).exists(); doReturn(null).when(this.importer).getContent(eq(mockResource)); assertThat(this.importer.doImportInto(mockRegion)).isEqualTo(mockRegion); verify(this.importer, times(1)).doImportInto(eq(mockRegion)); - verify(this.importer, times(1)) - .getResource(eq(mockRegion), eq(JsonCacheDataImporterExporter.CLASSPATH_RESOURCE_PREFIX)); + verify(this.importer, times(1)).getResource(eq(mockRegion), eq("classpath:")); verify(this.importer, times(1)).getContent(eq(mockResource)); verify(mockResource, times(1)).exists(); verifyNoMoreInteractions(this.importer); @@ -320,8 +311,7 @@ public class JsonCacheDataImporterExporterUnitTests { byte[] json = "[]".getBytes(); - doReturn(Optional.of(mockResource)).when(this.importer) - .getResource(eq(mockRegion), eq(JsonCacheDataImporterExporter.CLASSPATH_RESOURCE_PREFIX)); + doReturn(Optional.of(mockResource)).when(this.importer).getResource(eq(mockRegion), eq("classpath:")); doReturn(true).when(mockResource).exists(); doReturn(json).when(this.importer).getContent(eq(mockResource)); doReturn(new PdxInstance[0]).when(this.importer).toPdx(eq(json)); @@ -329,8 +319,7 @@ public class JsonCacheDataImporterExporterUnitTests { assertThat(this.importer.doImportInto(mockRegion)).isEqualTo(mockRegion); verify(this.importer, times(1)).doImportInto(eq(mockRegion)); - verify(this.importer, times(1)) - .getResource(eq(mockRegion), eq(JsonCacheDataImporterExporter.CLASSPATH_RESOURCE_PREFIX)); + verify(this.importer, times(1)).getResource(eq(mockRegion), eq("classpath:")); verify(this.importer, times(1)).getContent(eq(mockResource)); verify(this.importer, times(1)).toPdx(eq(json)); verify(mockResource, times(1)).exists(); @@ -469,7 +458,7 @@ public class JsonCacheDataImporterExporterUnitTests { public void getResourceFromNullRegion() { try { - this.importer.getResource(null, JsonCacheDataImporterExporter.CLASSPATH_RESOURCE_PREFIX); + this.importer.getResource(null, "classpath:"); } catch (IllegalArgumentException expected) { @@ -482,8 +471,8 @@ public class JsonCacheDataImporterExporterUnitTests { @Test public void getResourceLocationIsInWorkingDirectory() { - assertThat(this.importer.getResourceLocation()).isEqualTo(String.format("%1$s%2$s%3$s", - JsonCacheDataImporterExporter.FILESYSTEM_RESOURCE_PREFIX, System.getProperty("user.dir"), File.separator)); + assertThat(this.importer.getResourceLocation()).isEqualTo(String.format("file://%1$s%2$s", + System.getProperty("user.dir"), File.separator)); } @Test