Refactor and polish JSON and base cache data import/export support.

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<String> getDefaultProfilesIfEmpty(@Nullable Set<String> 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<String> resolvedProfiles = activeProfiles;
+		Assert.notNull(environment, "Environment must not be null");
 
-		if (CollectionUtils.nullSafeSet(activeProfiles).isEmpty()) {
+		boolean importProfilesActive = true;
 
-			Set<String> 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<String> cacheDataImportProfiles = commaDelimitedStringToSet(cacheDataImportActiveProfiles);
+
+		if (!cacheDataImportProfiles.isEmpty()) {
+
+			Set<String> 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<String> 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<String> getActiveProfiles(@NonNull Environment environment) {
+
+		return environment != null
+			? toSet(environment.getActiveProfiles(), String.class)
+			: Collections.emptySet();
+	}
+
+	@NonNull Set<String> useDefaultProfilesIfEmpty(@NonNull Environment environment,
+			@Nullable Set<String> activeProfiles) {
+
+		Set<String> resolvedProfiles = CollectionUtils.nullSafeSet(activeProfiles).stream()
+			.filter(StringUtils::hasText)
+			.collect(Collectors.toSet());
+
+		if (resolvedProfiles.isEmpty()) {
+
+			Set<String> 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<String> profiles) {
+	// The Set of configured Profiles cannot be null, empty or contain only the "default" Profile.
+	boolean isNotDefaultProfileOnlySet(@Nullable Set<String> 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<String> activeProfiles, String cacheDataImportActiveProfiles) {
-		return isNotSet(cacheDataImportActiveProfiles)
-			|| containsAny(activeProfiles, commaDelimitedListOfStringsToSet(cacheDataImportActiveProfiles));
-	}
-
-	Set<String> 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 <T> Set<T> toSet(T[] array, Class<T> type) {
+		return CollectionUtils.asSet(ArrayUtils.nullSafeArray(array, type));
 	}
 }

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);
 	}
 
 	/**

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<Region<?, ?>> 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<Region<?, ?>> 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> 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<Region<?, ?>> 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<Region<?, ?>> 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<Region<?, ?>> 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<Region<?, ?>> 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<Region<?, ?>> 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<Region<?, ?>> 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<Region<?, ?>> 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));
 		}
 	}
 }

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