From 0952f7efc3e7a3fd0c196fba6e73884aecf79eda Mon Sep 17 00:00:00 2001 From: John Blum Date: Tue, 11 Dec 2018 21:38:27 -0800 Subject: [PATCH] Add GemFireUtils.isNonLocalClientRegion(:Region) method. Remove GemFireUtils.toRegionPath(:String) method. --- .../AbstractGemFireIntegrationTests.java | 4 +- .../http/GemFireHttpSessionConfiguration.java | 3 +- .../SessionAttributesIndexFactoryBean.java | 4 +- .../data/gemfire/support/GemFireUtils.java | 75 ++++--- .../gemfire/support/GemFireUtilsTests.java | 198 +++++++++++++----- 5 files changed, 193 insertions(+), 91 deletions(-) diff --git a/spring-session-data-geode/src/integration-test/java/org/springframework/session/data/gemfire/AbstractGemFireIntegrationTests.java b/spring-session-data-geode/src/integration-test/java/org/springframework/session/data/gemfire/AbstractGemFireIntegrationTests.java index 4966275..e36114b 100644 --- a/spring-session-data-geode/src/integration-test/java/org/springframework/session/data/gemfire/AbstractGemFireIntegrationTests.java +++ b/spring-session-data-geode/src/integration-test/java/org/springframework/session/data/gemfire/AbstractGemFireIntegrationTests.java @@ -44,11 +44,11 @@ import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationListener; import org.springframework.data.gemfire.tests.integration.ForkingClientServerIntegrationTestsSupport; +import org.springframework.data.gemfire.util.RegionUtils; import org.springframework.lang.Nullable; import org.springframework.session.Session; import org.springframework.session.SessionRepository; import org.springframework.session.data.gemfire.config.annotation.web.http.GemFireHttpSessionConfiguration; -import org.springframework.session.data.gemfire.support.GemFireUtils; import org.springframework.session.events.AbstractSessionEvent; import org.springframework.util.StringUtils; @@ -306,7 +306,7 @@ public abstract class AbstractGemFireIntegrationTests extends ForkingClientServe assertThat(actualRegion).isNotNull(); assertThat(actualRegion.getName()).isEqualTo(expectedName); - assertThat(actualRegion.getFullPath()).isEqualTo(GemFireUtils.toRegionPath(expectedName)); + assertThat(actualRegion.getFullPath()).isEqualTo(RegionUtils.toRegionPath(expectedName)); assertThat(actualRegion.getAttributes()).isNotNull(); assertThat(actualRegion.getAttributes().getDataPolicy()).isEqualTo(expectedDataPolicy); } diff --git a/spring-session-data-geode/src/main/java/org/springframework/session/data/gemfire/config/annotation/web/http/GemFireHttpSessionConfiguration.java b/spring-session-data-geode/src/main/java/org/springframework/session/data/gemfire/config/annotation/web/http/GemFireHttpSessionConfiguration.java index 6845c88..3e3513d 100644 --- a/spring-session-data-geode/src/main/java/org/springframework/session/data/gemfire/config/annotation/web/http/GemFireHttpSessionConfiguration.java +++ b/spring-session-data-geode/src/main/java/org/springframework/session/data/gemfire/config/annotation/web/http/GemFireHttpSessionConfiguration.java @@ -69,6 +69,7 @@ import org.springframework.data.gemfire.IndexType; import org.springframework.data.gemfire.RegionAttributesFactoryBean; import org.springframework.data.gemfire.config.xml.GemfireConstants; import org.springframework.data.gemfire.util.ArrayUtils; +import org.springframework.data.gemfire.util.RegionUtils; import org.springframework.lang.NonNull; import org.springframework.lang.Nullable; import org.springframework.session.Session; @@ -1131,7 +1132,7 @@ public class GemFireHttpSessionConfiguration extends AbstractGemFireHttpSessionC principalNameIndex.setCache(gemfireCache); principalNameIndex.setName("principalNameIndex"); principalNameIndex.setExpression("principalName"); - principalNameIndex.setFrom(GemFireUtils.toRegionPath(getSessionRegionName())); + principalNameIndex.setFrom(RegionUtils.toRegionPath(getSessionRegionName())); principalNameIndex.setOverride(true); principalNameIndex.setType(IndexType.HASH); diff --git a/spring-session-data-geode/src/main/java/org/springframework/session/data/gemfire/config/annotation/web/http/support/SessionAttributesIndexFactoryBean.java b/spring-session-data-geode/src/main/java/org/springframework/session/data/gemfire/config/annotation/web/http/support/SessionAttributesIndexFactoryBean.java index 91fda05..9727475 100644 --- a/spring-session-data-geode/src/main/java/org/springframework/session/data/gemfire/config/annotation/web/http/support/SessionAttributesIndexFactoryBean.java +++ b/spring-session-data-geode/src/main/java/org/springframework/session/data/gemfire/config/annotation/web/http/support/SessionAttributesIndexFactoryBean.java @@ -30,7 +30,7 @@ import org.springframework.beans.factory.BeanNameAware; import org.springframework.beans.factory.FactoryBean; import org.springframework.beans.factory.InitializingBean; import org.springframework.data.gemfire.IndexFactoryBean; -import org.springframework.session.data.gemfire.support.GemFireUtils; +import org.springframework.data.gemfire.util.RegionUtils; import org.springframework.util.ObjectUtils; /** @@ -97,7 +97,7 @@ public class SessionAttributesIndexFactoryBean indexFactory.setName("sessionAttributesIndex"); indexFactory.setExpression(String.format("s.attributes[%1$s]", getIndexableSessionAttributesAsGemFireIndexExpression())); - indexFactory.setFrom(String.format("%1$s s", GemFireUtils.toRegionPath(this.regionName))); + indexFactory.setFrom(String.format("%1$s s", RegionUtils.toRegionPath(this.regionName))); indexFactory.setOverride(true); indexFactory.afterPropertiesSet(); diff --git a/spring-session-data-geode/src/main/java/org/springframework/session/data/gemfire/support/GemFireUtils.java b/spring-session-data-geode/src/main/java/org/springframework/session/data/gemfire/support/GemFireUtils.java index 3839f2b..abe926a 100644 --- a/spring-session-data-geode/src/main/java/org/springframework/session/data/gemfire/support/GemFireUtils.java +++ b/spring-session-data-geode/src/main/java/org/springframework/session/data/gemfire/support/GemFireUtils.java @@ -28,8 +28,12 @@ import org.apache.geode.cache.RegionAttributes; import org.apache.geode.cache.RegionShortcut; import org.apache.geode.cache.client.ClientCache; import org.apache.geode.cache.client.ClientRegionShortcut; +import org.apache.geode.internal.cache.AbstractRegion; import org.apache.geode.internal.cache.GemFireCacheImpl; +import org.springframework.lang.Nullable; +import org.springframework.util.StringUtils; + /** * {@link GemFireUtils} is an abstract, extensible utility class for working with Apache Geode and Pivotal GemFire * objects and types. @@ -72,7 +76,7 @@ public abstract class GemFireUtils { * @see org.apache.geode.cache.client.ClientCache * @see org.apache.geode.cache.GemFireCache */ - public static boolean isClient(GemFireCache gemfireCache) { + public static boolean isClient(@Nullable GemFireCache gemfireCache) { boolean client = gemfireCache instanceof ClientCache; @@ -89,30 +93,57 @@ public abstract class GemFireUtils { * @see org.apache.geode.cache.Cache * @see org.apache.geode.cache.GemFireCache */ - public static boolean isPeer(GemFireCache gemFireCache) { + public static boolean isPeer(@Nullable GemFireCache gemFireCache) { return gemFireCache instanceof Cache && !isClient(gemFireCache); } /** * Determines whether the given {@link ClientRegionShortcut} is local only. * - * @param shortcut the ClientRegionShortcut to evaluate. - * @return a boolean value indicating if the {@link ClientRegionShortcut} is local or - * not. + * @param shortcut {@link ClientRegionShortcut} to evaluate. + * @return a boolean value indicating whether the {@link ClientRegionShortcut} is local or not. * @see org.apache.geode.cache.client.ClientRegionShortcut */ - public static boolean isLocal(ClientRegionShortcut shortcut) { + public static boolean isLocal(@Nullable ClientRegionShortcut shortcut) { + return shortcut != null && shortcut.name().toLowerCase().contains("local"); + } - switch (shortcut) { - case LOCAL: - case LOCAL_HEAP_LRU: - case LOCAL_OVERFLOW: - case LOCAL_PERSISTENT: - case LOCAL_PERSISTENT_OVERFLOW: - return true; - default: - return false; - } + /** + * Determines whether the given {@link Region} is a non-local, client {@link Region}, a {@link Region} + * for which a corresponding server {@link Region} exists. + * + * @param region {@link Region} to evaluate. + * @return a boolean value indicating whether the given {@link Region} is a non-local, client {@link Region}, + * a {@link Region} for which a corresponding server {@link Region} exists. + * @see org.apache.geode.cache.Region + * @see #isPoolConfiguredOrHasServerProxy(Region) + */ + public static boolean isNonLocalClientRegion(@Nullable Region region) { + + return Optional.ofNullable(region) + .filter(GemFireUtils::isPoolConfiguredOrHasServerProxy) + .map(Region::getRegionService) + .filter(GemFireCache.class::isInstance) + .map(GemFireCache.class::cast) + .filter(GemFireUtils::isClient) + .isPresent(); + } + + private static boolean isPoolConfiguredOrHasServerProxy(@Nullable Region region) { + return isPoolConfigured(region) || hasServerProxy(region); + } + + private static boolean isPoolConfigured(@Nullable Region region) { + + return Optional.ofNullable(region) + .map(Region::getAttributes) + .map(RegionAttributes::getPoolName) + .filter(StringUtils::hasText) + .isPresent(); + } + + private static boolean hasServerProxy(@Nullable Region region) { + return region instanceof AbstractRegion && ((AbstractRegion) region).hasServerProxy(); } /** @@ -176,16 +207,4 @@ public abstract class GemFireUtils { return false; } } - - /** - * Converts a {@link Region} name to a {@link Region} path. - * - * @param regionName a String specifying the name of the {@link Region}. - * @return a String path for the given {@link Region} by name. - * @see org.apache.geode.cache.Region#getFullPath() - * @see org.apache.geode.cache.Region#getName() - */ - public static String toRegionPath(String regionName) { - return String.format("%1$s%2$s", Region.SEPARATOR, regionName); - } } diff --git a/spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/support/GemFireUtilsTests.java b/spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/support/GemFireUtilsTests.java index bd7d603..2359f95 100644 --- a/spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/support/GemFireUtilsTests.java +++ b/spring-session-data-geode/src/test/java/org/springframework/session/data/gemfire/support/GemFireUtilsTests.java @@ -17,15 +17,16 @@ package org.springframework.session.data.gemfire.support; import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.BDDMockito.given; import static org.mockito.Mockito.doThrow; 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.when; import java.io.Closeable; import java.io.IOException; +import java.util.Arrays; import org.junit.Test; @@ -38,12 +39,12 @@ import org.apache.geode.cache.RegionAttributes; import org.apache.geode.cache.RegionShortcut; import org.apache.geode.cache.client.ClientCache; import org.apache.geode.cache.client.ClientRegionShortcut; +import org.apache.geode.internal.cache.AbstractRegion; /** * Unit tests for {@link GemFireUtils}. * * @author John Blum - * @since 1.1.0 * @see org.junit.Test * @see org.mockito.Mockito * @see org.apache.geode.cache.Cache @@ -51,6 +52,7 @@ import org.apache.geode.cache.client.ClientRegionShortcut; * @see org.apache.geode.cache.Region * @see org.apache.geode.cache.client.ClientCache * @see org.springframework.session.data.gemfire.support.GemFireUtils + * @since 1.1.0 */ public class GemFireUtilsTests { @@ -91,6 +93,11 @@ public class GemFireUtilsTests { assertThat(GemFireUtils.isClient(mock(GemFireCache.class))).isFalse(); } + @Test + public void nullIsNotClient() { + assertThat(GemFireUtils.isClient(null)).isFalse(); + } + @Test public void peerCacheIsNotClient() { assertThat(GemFireUtils.isClient(mock(Cache.class))).isFalse(); @@ -101,6 +108,11 @@ public class GemFireUtilsTests { assertThat(GemFireUtils.isPeer(mock(Cache.class))).isTrue(); } + @Test + public void nullIsNotPeer() { + assertThat(GemFireUtils.isPeer(null)).isFalse(); + } + @Test public void genericCacheIsNotPeer() { assertThat(GemFireUtils.isPeer(mock(GemFireCache.class))).isFalse(); @@ -114,20 +126,17 @@ public class GemFireUtilsTests { @Test public void clientRegionShortcutIsLocal() { - assertThat(GemFireUtils.isLocal(ClientRegionShortcut.LOCAL)).isTrue(); - assertThat(GemFireUtils.isLocal(ClientRegionShortcut.LOCAL_HEAP_LRU)).isTrue(); - assertThat(GemFireUtils.isLocal(ClientRegionShortcut.LOCAL_OVERFLOW)).isTrue(); - assertThat(GemFireUtils.isLocal(ClientRegionShortcut.LOCAL_PERSISTENT)).isTrue(); - assertThat(GemFireUtils.isLocal(ClientRegionShortcut.LOCAL_PERSISTENT_OVERFLOW)).isTrue(); + Arrays.stream(ClientRegionShortcut.values()) + .filter(it -> it.name().toLowerCase().contains("local")) + .forEach(it -> assertThat(GemFireUtils.isLocal(it)).isTrue()); } @Test public void clientRegionShortcutIsNotLocal() { - assertThat(GemFireUtils.isLocal(ClientRegionShortcut.CACHING_PROXY)).isFalse(); - assertThat(GemFireUtils.isLocal(ClientRegionShortcut.CACHING_PROXY_HEAP_LRU)).isFalse(); - assertThat(GemFireUtils.isLocal(ClientRegionShortcut.CACHING_PROXY_OVERFLOW)).isFalse(); - assertThat(GemFireUtils.isLocal(ClientRegionShortcut.PROXY)).isFalse(); + Arrays.stream(ClientRegionShortcut.values()) + .filter(it -> !it.name().toLowerCase().contains("local")) + .forEach(it -> assertThat(GemFireUtils.isLocal(it)).isFalse()); } @Test @@ -138,14 +147,114 @@ public class GemFireUtilsTests { @Test public void clientRegionShortcutIsNotProxy() { - assertThat(GemFireUtils.isProxy(ClientRegionShortcut.CACHING_PROXY)).isFalse(); - assertThat(GemFireUtils.isProxy(ClientRegionShortcut.CACHING_PROXY_HEAP_LRU)).isFalse(); - assertThat(GemFireUtils.isProxy(ClientRegionShortcut.CACHING_PROXY_OVERFLOW)).isFalse(); - assertThat(GemFireUtils.isProxy(ClientRegionShortcut.LOCAL)).isFalse(); - assertThat(GemFireUtils.isProxy(ClientRegionShortcut.LOCAL_HEAP_LRU)).isFalse(); - assertThat(GemFireUtils.isProxy(ClientRegionShortcut.LOCAL_OVERFLOW)).isFalse(); - assertThat(GemFireUtils.isProxy(ClientRegionShortcut.LOCAL_PERSISTENT)).isFalse(); - assertThat(GemFireUtils.isProxy(ClientRegionShortcut.LOCAL_PERSISTENT_OVERFLOW)).isFalse(); + Arrays.stream(ClientRegionShortcut.values()) + .filter(it -> !ClientRegionShortcut.PROXY.equals(it)) + .forEach(it -> assertThat(GemFireUtils.isProxy(it)).isFalse()); + } + + @Test + public void clientRegionWithPoolIsNonLocalClientRegion() { + + ClientCache mockClientCache = mock(ClientCache.class); + + Region mockRegion = mock(Region.class); + + RegionAttributes mockRegionAttributes = mock(RegionAttributes.class); + + when(mockRegion.getAttributes()).thenReturn(mockRegionAttributes); + when(mockRegion.getRegionService()).thenReturn(mockClientCache); + when(mockRegionAttributes.getPoolName()).thenReturn("Dead"); + + assertThat(GemFireUtils.isNonLocalClientRegion(mockRegion)).isTrue(); + + verify(mockRegion, times(1)).getAttributes(); + verify(mockRegion, times(1)).getRegionService(); + verify(mockRegionAttributes, times(1)).getPoolName(); + } + + @Test + public void clientRegionWithServerProxyIsNonLocalClientRegion() { + + ClientCache mockClientCache = mock(ClientCache.class); + + AbstractRegion mockRegion = mock(AbstractRegion.class); + + RegionAttributes mockRegionAttributes = mock(RegionAttributes.class); + + when(mockRegion.getAttributes()).thenReturn(mockRegionAttributes); + when(mockRegion.getRegionService()).thenReturn(mockClientCache); + when(mockRegion.hasServerProxy()).thenReturn(true); + when(mockRegionAttributes.getPoolName()).thenReturn(" "); + + assertThat(GemFireUtils.isNonLocalClientRegion(mockRegion)).isTrue(); + + verify(mockRegion, times(1)).getAttributes(); + verify(mockRegion, times(1)).getRegionService(); + verify(mockRegion, times(1)).hasServerProxy(); + verify(mockRegionAttributes, times(1)).getPoolName(); + } + + @Test + public void clientRegionWithNoPoolAndNoServerProxyIsNotNonLocalClientRegion() { + + ClientCache mockClientCache = mock(ClientCache.class); + + AbstractRegion mockRegion = mock(AbstractRegion.class); + + RegionAttributes mockRegionAttributes = mock(RegionAttributes.class); + + when(mockRegion.getAttributes()).thenReturn(mockRegionAttributes); + when(mockRegion.getRegionService()).thenReturn(mockClientCache); + when(mockRegion.hasServerProxy()).thenReturn(false); + when(mockRegionAttributes.getPoolName()).thenReturn(null); + + assertThat(GemFireUtils.isNonLocalClientRegion(mockRegion)).isFalse(); + + verify(mockRegion, times(1)).getAttributes(); + verify(mockRegion, never()).getRegionService(); + verify(mockRegion, times(1)).hasServerProxy(); + verify(mockRegionAttributes, times(1)).getPoolName(); + } + + @Test + public void nonClientRegionWithPoolIsNotNonLocalClientRegion() { + + GemFireCache mockGemFireCache = mock(GemFireCache.class); + + Region mockRegion = mock(Region.class); + + RegionAttributes mockRegionAttributes = mock(RegionAttributes.class); + + when(mockRegion.getAttributes()).thenReturn(mockRegionAttributes); + when(mockRegion.getRegionService()).thenReturn(mockGemFireCache); + when(mockRegionAttributes.getPoolName()).thenReturn("Car"); + + assertThat(GemFireUtils.isNonLocalClientRegion(mockRegion)).isFalse(); + + verify(mockRegion, times(1)).getAttributes(); + verify(mockRegion, times(1)).getRegionService(); + verify(mockRegionAttributes, times(1)).getPoolName(); + } + + @Test + public void peerRegionWithServerProxyIsNotNonLocalClientRegion() { + + Cache mockPeerCache = mock(Cache.class); + + AbstractRegion mockRegion = mock(AbstractRegion.class); + + RegionAttributes mockRegionAttributes = mock(RegionAttributes.class); + + when(mockRegion.getAttributes()).thenReturn(mockRegionAttributes); + when(mockRegion.getRegionService()).thenReturn(mockPeerCache); + when(mockRegion.hasServerProxy()).thenReturn(true); + when(mockRegionAttributes.getPoolName()).thenReturn(""); + + assertThat(GemFireUtils.isNonLocalClientRegion(mockRegion)).isFalse(); + + verify(mockRegion, times(1)).getAttributes(); + verify(mockRegion, times(1)).getRegionService(); + verify(mockRegionAttributes, times(1)).getPoolName(); } @Test @@ -215,8 +324,8 @@ public class GemFireUtilsTests { RegionAttributes mockRegionAttributes = mock(RegionAttributes.class); - given(mockRegion.getAttributes()).willReturn(mockRegionAttributes); - given(mockRegionAttributes.getDataPolicy()).willReturn(DataPolicy.NORMAL); + when(mockRegion.getAttributes()).thenReturn(mockRegionAttributes); + when(mockRegionAttributes.getDataPolicy()).thenReturn(DataPolicy.NORMAL); assertThat(GemFireUtils.isProxy(mockRegion)).isFalse(); @@ -271,8 +380,8 @@ public class GemFireUtilsTests { RegionAttributes mockRegionAttributes = mock(RegionAttributes.class); - given(mockRegion.getAttributes()).willReturn(mockRegionAttributes); - given(mockRegionAttributes.getDataPolicy()).willReturn(DataPolicy.PRELOADED); + when(mockRegion.getAttributes()).thenReturn(mockRegionAttributes); + when(mockRegionAttributes.getDataPolicy()).thenReturn(DataPolicy.PRELOADED); assertThat(GemFireUtils.isProxy(mockRegion)).isFalse(); @@ -287,8 +396,8 @@ public class GemFireUtilsTests { RegionAttributes mockRegionAttributes = mock(RegionAttributes.class); - given(mockRegion.getAttributes()).willReturn(mockRegionAttributes); - given(mockRegionAttributes.getDataPolicy()).willReturn(DataPolicy.REPLICATE); + when(mockRegion.getAttributes()).thenReturn(mockRegionAttributes); + when(mockRegionAttributes.getDataPolicy()).thenReturn(DataPolicy.REPLICATE); assertThat(GemFireUtils.isProxy(mockRegion)).isFalse(); @@ -299,43 +408,16 @@ public class GemFireUtilsTests { @Test public void regionShortcutIsProxy() { - assertThat(GemFireUtils.isProxy(RegionShortcut.PARTITION_PROXY)).isTrue(); - assertThat(GemFireUtils.isProxy(RegionShortcut.PARTITION_PROXY_REDUNDANT)).isTrue(); - assertThat(GemFireUtils.isProxy(RegionShortcut.REPLICATE_PROXY)).isTrue(); + Arrays.stream(RegionShortcut.values()) + .filter(it -> it.name().toLowerCase().contains("proxy")) + .forEach(it -> assertThat(GemFireUtils.isProxy(it)).isTrue()); } @Test public void regionShortcutIsNotProxy() { - assertThat(GemFireUtils.isProxy(RegionShortcut.LOCAL)).isFalse(); - assertThat(GemFireUtils.isProxy(RegionShortcut.LOCAL_HEAP_LRU)).isFalse(); - assertThat(GemFireUtils.isProxy(RegionShortcut.LOCAL_OVERFLOW)).isFalse(); - assertThat(GemFireUtils.isProxy(RegionShortcut.LOCAL_PERSISTENT)).isFalse(); - assertThat(GemFireUtils.isProxy(RegionShortcut.LOCAL_PERSISTENT_OVERFLOW)).isFalse(); - assertThat(GemFireUtils.isProxy(RegionShortcut.REPLICATE)).isFalse(); - assertThat(GemFireUtils.isProxy(RegionShortcut.REPLICATE_HEAP_LRU)).isFalse(); - assertThat(GemFireUtils.isProxy(RegionShortcut.REPLICATE_OVERFLOW)).isFalse(); - assertThat(GemFireUtils.isProxy(RegionShortcut.REPLICATE_PERSISTENT)).isFalse(); - assertThat(GemFireUtils.isProxy(RegionShortcut.REPLICATE_PERSISTENT_OVERFLOW)).isFalse(); - assertThat(GemFireUtils.isProxy(RegionShortcut.PARTITION)).isFalse(); - assertThat(GemFireUtils.isProxy(RegionShortcut.PARTITION_HEAP_LRU)).isFalse(); - assertThat(GemFireUtils.isProxy(RegionShortcut.PARTITION_OVERFLOW)).isFalse(); - assertThat(GemFireUtils.isProxy(RegionShortcut.PARTITION_PERSISTENT)).isFalse(); - assertThat(GemFireUtils.isProxy(RegionShortcut.PARTITION_PERSISTENT_OVERFLOW)).isFalse(); - assertThat(GemFireUtils.isProxy(RegionShortcut.PARTITION_REDUNDANT)).isFalse(); - assertThat(GemFireUtils.isProxy(RegionShortcut.PARTITION_REDUNDANT_HEAP_LRU)).isFalse(); - assertThat(GemFireUtils.isProxy(RegionShortcut.PARTITION_REDUNDANT_OVERFLOW)).isFalse(); - assertThat(GemFireUtils.isProxy(RegionShortcut.PARTITION_REDUNDANT_PERSISTENT)).isFalse(); - assertThat(GemFireUtils.isProxy(RegionShortcut.PARTITION_REDUNDANT_PERSISTENT_OVERFLOW)).isFalse(); - } - - @Test - public void toRegionPath() { - - assertThat(GemFireUtils.toRegionPath("A")).isEqualTo("/A"); - assertThat(GemFireUtils.toRegionPath("Example")).isEqualTo("/Example"); - assertThat(GemFireUtils.toRegionPath("/Example")).isEqualTo("//Example"); - assertThat(GemFireUtils.toRegionPath("/")).isEqualTo("//"); - assertThat(GemFireUtils.toRegionPath("")).isEqualTo("/"); + Arrays.stream(RegionShortcut.values()) + .filter(it -> !it.name().toLowerCase().contains("proxy")) + .forEach(it -> assertThat(GemFireUtils.isProxy(it)).isFalse()); } }