Spring/spring-data-geode
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

DATAGEODE-61 - Do not configure ClientRegionFactory poolName when Pool is set to DEFAULT.

Browse Source
This commit is contained in:
John Blum
2017-11-21 01:35:19 -08:00
parent 5129cb04de
commit 6cb0ebca19
5 changed files with 574 additions and 263 deletions
Download Patch File Download Diff File Expand all files Collapse all files

76
src/main/java/org/springframework/data/gemfire/client/ClientRegionFactoryBean.java
View File

@@ -131,10 +131,10 @@ public class ClientRegionFactoryBean<K, V> extends RegionLookupFactoryBean<K, V>
applyRegionConfigurers(regionName);
ClientCache cache = resolveCache(gemfireCache);
ClientCache clientCache = resolveCache(gemfireCache);
ClientRegionFactory<K, V> clientRegionFactory =
postProcess(configure(createClientRegionFactory(cache, resolveClientRegionShortcut())));
postProcess(configure(createClientRegionFactory(clientCache, resolveClientRegionShortcut())));
@SuppressWarnings("all")
Region<K, V> region = newRegion(clientRegionFactory, getParent(), regionName);
@@ -295,17 +295,22 @@ public class ClientRegionFactoryBean<K, V> extends RegionLookupFactoryBean<K, V>
/* (non-Javadoc) */
private String resolvePoolName() {
return Optional.of(getPoolName()).filter(this::isPoolResolvable).orElse(null);
return getPoolName()
.filter(StringUtils::hasText)
.filter(this::isNotDefaultPool)
.filter(this::isPoolResolvable)
.orElse(null);
}
/* (non-Javadoc) */
private String getPoolName() {
return Optional.ofNullable(this.poolName).filter(StringUtils::hasText).orElse(GEMFIRE_POOL_NAME);
boolean isPoolResolvable(String poolName) {
return getBeanFactory().containsBean(poolName) || (PoolManager.find(poolName) != null);
}
/* (non-Javadoc) */
private boolean isPoolResolvable(String poolName) {
return (getBeanFactory().containsBean(poolName) || (PoolManager.find(poolName) != null));
boolean isNotDefaultPool(String poolName) {
return !DEFAULT_POOL_NAME.equals(poolName);
}
/* (non-Javadoc) */
@@ -328,15 +333,17 @@ public class ClientRegionFactoryBean<K, V> extends RegionLookupFactoryBean<K, V>
* Constructs a new instance of {@link ClientRegionFactory} using the given {@link ClientCache}
* and {@link ClientRegionShortcut}.
*
* @param cache reference to the {@link ClientCache}.
* @param clientCache reference to the {@link ClientCache}.
* @param shortcut {@link ClientRegionShortcut} used to specify the client {@link Region} {@link DataPolicy}.
* @return a new instance of {@link ClientRegionFactory}.
* @see org.apache.geode.cache.client.ClientCache#createClientRegionFactory(ClientRegionShortcut)
* @see org.apache.geode.cache.client.ClientRegionShortcut
* @see org.apache.geode.cache.client.ClientRegionFactory
*/
protected ClientRegionFactory<K, V> createClientRegionFactory(ClientCache cache, ClientRegionShortcut shortcut) {
return cache.createClientRegionFactory(shortcut);
protected ClientRegionFactory<K, V> createClientRegionFactory(ClientCache clientCache,
ClientRegionShortcut shortcut) {
return clientCache.createClientRegionFactory(shortcut);
}
/**
@@ -368,11 +375,18 @@ public class ClientRegionFactoryBean<K, V> extends RegionLookupFactoryBean<K, V>
clientRegionFactory.setInitialCapacity(attributes.getInitialCapacity());
clientRegionFactory.setKeyConstraint(attributes.getKeyConstraint());
clientRegionFactory.setLoadFactor(attributes.getLoadFactor());
clientRegionFactory.setPoolName(attributes.getPoolName());
clientRegionFactory.setRegionIdleTimeout(attributes.getRegionIdleTimeout());
clientRegionFactory.setRegionTimeToLive(attributes.getRegionTimeToLive());
clientRegionFactory.setStatisticsEnabled(attributes.getStatisticsEnabled());
clientRegionFactory.setValueConstraint(attributes.getValueConstraint());
Optional.ofNullable(attributes.getPoolName())
.filter(StringUtils::hasText)
.filter(this::isNotDefaultPool)
.filter(this::isPoolResolvable)
.map(this::eagerlyInitializePool)
.ifPresent(clientRegionFactory::setPoolName);
});
stream(nullSafeArray(this.cacheListeners, CacheListener.class)).forEach(clientRegionFactory::addCacheListener);
@@ -384,8 +398,9 @@ public class ClientRegionFactoryBean<K, V> extends RegionLookupFactoryBean<K, V>
Optional.ofNullable(this.keyConstraint).ifPresent(clientRegionFactory::setKeyConstraint);
Optional.ofNullable(resolvePoolName()).filter(StringUtils::hasText)
.ifPresent(poolName -> clientRegionFactory.setPoolName(eagerlyInitializePool(poolName)));
Optional.ofNullable(resolvePoolName())
.map(this::eagerlyInitializePool)
.ifPresent(clientRegionFactory::setPoolName);
Optional.ofNullable(this.valueConstraint).ifPresent(clientRegionFactory::setValueConstraint);
@@ -639,22 +654,34 @@ public class ClientRegionFactoryBean<K, V> extends RegionLookupFactoryBean<K, V>
/**
* Sets the {@link Pool} used by this client {@link Region}.
*
* @param pool GemFire client {@link Pool}.
* @param pool client {@link Pool} to be used by this client {@link Region}.
* @see org.apache.geode.cache.client.Pool
* @see #setPoolName(String)
*/
public void setPool(Pool pool) {
setPoolName(Optional.ofNullable(pool).map(Pool::getName)
.orElseThrow(() -> newIllegalArgumentException("Pool cannot be null")));
setPoolName(Optional.ofNullable(pool).map(Pool::getName).orElse(null));
}
/**
* Sets the {@link Pool} name used by this client {@link Region}.
* Sets the {@link String name} of the {@link Pool} used by this client {@link Region}.
*
* @param poolName String specifying the name of the GemFire client {@link Pool}.
* @param poolName {@link String} containing the name of the client {@link Pool} used by this client {@link Region}.
* @see #getPoolName()
* @see #setPool(Pool)
*/
public void setPoolName(String poolName) {
this.poolName = Optional.ofNullable(poolName).filter(StringUtils::hasText)
.orElseThrow(() -> newIllegalArgumentException("Pool name is required"));
this.poolName = poolName;
}
/**
* Returns the {@link String name} of the configured {@link Pool} to use with this client {@link Region}.
*
* @return the {@link Optional} {@link String name} of the configured {@link Pool} to use
* with this client {@link Region}.
* @see #setPoolName(String)
*/
public Optional<String> getPoolName() {
return Optional.ofNullable(this.poolName);
}
/**
@@ -683,14 +710,21 @@ public class ClientRegionFactoryBean<K, V> extends RegionLookupFactoryBean<K, V>
}
/**
* Initializes the client {@link Region} using a GemFire {@link ClientRegionShortcut}.
* Initializes the client {@link Region} using the given {@link ClientRegionShortcut}.
*
* @param shortcut {@link ClientRegionShortcut} used to initialize this client {@link Region}.
* @see org.apache.geode.cache.client.ClientRegionShortcut
*/
public void setShortcut(ClientRegionShortcut shortcut) {
this.shortcut = shortcut;
}
/**
* Sets a {@link Class type} constraint on this {@link Region Region's} values.
*
* @param valueConstraint {@link Class type} of this client {@link Region Region's} values.
* @see java.lang.Class
*/
public void setValueConstraint(Class<V> valueConstraint) {
this.valueConstraint = valueConstraint;
}

514
src/test/java/org/springframework/data/gemfire/client/ClientRegionFactoryBeanTest.java
View File

@@ -15,23 +15,24 @@
*/
package org.springframework.data.gemfire.client;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.notNullValue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq;
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.spy;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyZeroInteractions;
import static org.mockito.Mockito.when;
import java.io.InputStream;
@@ -50,10 +51,11 @@ import org.apache.geode.compression.Compressor;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InOrder;
import org.springframework.beans.factory.BeanCreationException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.core.io.Resource;
import org.springframework.data.gemfire.TestUtils;
import org.springframework.data.gemfire.config.xml.GemfireConstants;
import org.springframework.data.gemfire.util.ArrayUtils;
/**
@@ -77,7 +79,7 @@ public class ClientRegionFactoryBeanTest {
@Before
public void setup() {
factoryBean = new ClientRegionFactoryBean<>();
factoryBean = spy(new ClientRegionFactoryBean<>());
}
@After
@@ -88,7 +90,7 @@ public class ClientRegionFactoryBeanTest {
@Test
@SuppressWarnings({ "deprecation", "unchecked" })
public void testLookupFallbackUsingDefaultShortcut() throws Exception {
public void createRegionUsingDefaultShortcut() throws Exception {
String testRegionName = "TestRegion";
@@ -98,11 +100,11 @@ public class ClientRegionFactoryBeanTest {
Region mockRegion = mock(Region.class);
when(mockClientCache.createClientRegionFactory(eq(ClientRegionShortcut.LOCAL))).thenReturn(mockClientRegionFactory);
when(mockClientRegionFactory.create(eq(testRegionName))).thenReturn(mockRegion);
RegionAttributes mockRegionAttributes = mock(RegionAttributes.class);
when(mockClientCache.createClientRegionFactory(eq(ClientRegionShortcut.LOCAL)))
.thenReturn(mockClientRegionFactory);
when(mockClientRegionFactory.create(eq(testRegionName))).thenReturn(mockRegion);
when(mockRegionAttributes.getCloningEnabled()).thenReturn(false);
when(mockRegionAttributes.getCompressor()).thenReturn(mock(Compressor.class));
when(mockRegionAttributes.getConcurrencyChecksEnabled()).thenReturn(true);
@@ -124,9 +126,12 @@ public class ClientRegionFactoryBeanTest {
when(mockRegionAttributes.getValueConstraint()).thenReturn(Number.class);
BeanFactory mockBeanFactory = mock(BeanFactory.class);
Pool mockPool = mock(Pool.class);
Resource mockSnapshot = mock(Resource.class, "Snapshot");
when(mockBeanFactory.containsBean(eq("TestPoolOne"))).thenReturn(false);
when(mockBeanFactory.containsBean(eq("TestPoolTwo"))).thenReturn(true);
when(mockBeanFactory.isTypeMatch(eq("TestPoolTwo"), eq(Pool.class))).thenReturn(true);
when(mockBeanFactory.getBean(eq("TestPoolTwo"))).thenReturn(mockPool);
@@ -163,7 +168,7 @@ public class ClientRegionFactoryBeanTest {
verify(mockClientRegionFactory, times(1)).setInitialCapacity(eq(101));
verify(mockClientRegionFactory, times(1)).setKeyConstraint(eq(Long.class));
verify(mockClientRegionFactory, times(1)).setLoadFactor(eq(0.75f));
verify(mockClientRegionFactory, times(1)).setPoolName(eq("TestPoolOne"));
verify(mockClientRegionFactory, never()).setPoolName(eq("TestPoolOne"));
verify(mockClientRegionFactory, times(1)).setRegionIdleTimeout(any(ExpirationAttributes.class));
verify(mockClientRegionFactory, times(1)).setRegionTimeToLive(any(ExpirationAttributes.class));
verify(mockClientRegionFactory, times(1)).setStatisticsEnabled(eq(true));
@@ -176,7 +181,7 @@ public class ClientRegionFactoryBeanTest {
@Test
@SuppressWarnings({ "deprecation", "unchecked" })
public void testLookupFallbackUsingDefaultPersistentShortcut() throws Exception {
public void createRegionUsingDefaultPersistentShortcut() throws Exception {
ClientCache mockClientCache = mock(ClientCache.class);
@@ -184,7 +189,8 @@ public class ClientRegionFactoryBeanTest {
Region<Object, Object> mockRegion = mock(Region.class);
when(mockClientCache.createClientRegionFactory(eq(ClientRegionShortcut.LOCAL_PERSISTENT))).thenReturn(mockClientRegionFactory);
when(mockClientCache.createClientRegionFactory(eq(ClientRegionShortcut.LOCAL_PERSISTENT)))
.thenReturn(mockClientRegionFactory);
when(mockClientRegionFactory.create(eq("TestRegion"))).thenReturn(mockRegion);
BeanFactory mockBeanFactory = mock(BeanFactory.class);
@@ -192,11 +198,9 @@ public class ClientRegionFactoryBeanTest {
when(mockBeanFactory.containsBean(eq("TestPool"))).thenReturn(true);
when(mockBeanFactory.isTypeMatch(eq("TestPool"), eq(Pool.class))).thenReturn(false);
factoryBean.setAttributes(null);
factoryBean.setBeanFactory(mockBeanFactory);
factoryBean.setPersistent(true);
factoryBean.setPoolName("TestPool");
factoryBean.setShortcut(null);
Region<Object, Object> actualRegion = factoryBean.createRegion(mockClientCache, "TestRegion");
@@ -212,7 +216,7 @@ public class ClientRegionFactoryBeanTest {
@Test
@SuppressWarnings("unchecked")
public void testLookupFallbackWithSpecifiedShortcut() throws Exception {
public void createRegionWithSpecifiedShortcut() throws Exception {
BeanFactory mockBeanFactory = mock(BeanFactory.class);
@@ -222,12 +226,10 @@ public class ClientRegionFactoryBeanTest {
Region<Object, Object> mockRegion = mock(Region.class);
when(mockBeanFactory.containsBean(anyString())).thenReturn(true);
when(mockClientCache.createClientRegionFactory(eq(ClientRegionShortcut.CACHING_PROXY)))
.thenReturn(mockClientRegionFactory);
when(mockClientRegionFactory.create(eq("TestRegion"))).thenReturn(mockRegion);
factoryBean.setAttributes(null);
factoryBean.setBeanFactory(mockBeanFactory);
factoryBean.setShortcut(ClientRegionShortcut.CACHING_PROXY);
@@ -235,14 +237,15 @@ public class ClientRegionFactoryBeanTest {
assertSame(mockRegion, actualRegion);
verify(mockBeanFactory, times(1)).containsBean(eq(GemfireConstants.DEFAULT_GEMFIRE_POOL_NAME));
verify(mockClientCache, times(1)).createClientRegionFactory(eq(ClientRegionShortcut.CACHING_PROXY));
verifyZeroInteractions(mockBeanFactory);
verify(mockClientCache, times(1))
.createClientRegionFactory(eq(ClientRegionShortcut.CACHING_PROXY));
verify(mockClientRegionFactory, times(1)).create(eq("TestRegion"));
}
@Test
@SuppressWarnings("unchecked")
public void testLookupFallbackWithSubRegionCreation() throws Exception {
public void createRegionWithSubRegionCreation() throws Exception {
BeanFactory mockBeanFactory = mock(BeanFactory.class);
@@ -253,12 +256,10 @@ public class ClientRegionFactoryBeanTest {
Region<Object, Object> mockRegion = mock(Region.class, "RootRegion");
Region<Object, Object> mockSubRegion = mock(Region.class, "SubRegion");
when(mockBeanFactory.containsBean(anyString())).thenReturn(true);
when(mockClientCache.createClientRegionFactory(eq(ClientRegionShortcut.PROXY))).thenReturn(mockClientRegionFactory);
when(mockClientRegionFactory.createSubregion(eq(mockRegion), eq("TestSubRegion"))).thenReturn(mockSubRegion);
when(mockRegion.getName()).thenReturn("Parent");
factoryBean.setAttributes(null);
factoryBean.setBeanFactory(mockBeanFactory);
factoryBean.setParent(mockRegion);
factoryBean.setShortcut(ClientRegionShortcut.PROXY);
@@ -267,58 +268,383 @@ public class ClientRegionFactoryBeanTest {
assertSame(mockSubRegion, actualRegion);
verify(mockBeanFactory, times(1)).containsBean(eq(GemfireConstants.DEFAULT_GEMFIRE_POOL_NAME));
verify(mockClientCache, times(1)).createClientRegionFactory(eq(ClientRegionShortcut.PROXY));
verify(mockClientRegionFactory, times(1)).createSubregion(eq(mockRegion), eq("TestSubRegion"));
verifyZeroInteractions(mockBeanFactory);
verify(mockClientCache, times(1))
.createClientRegionFactory(eq(ClientRegionShortcut.PROXY));
verify(mockClientRegionFactory, times(1))
.createSubregion(eq(mockRegion), eq("TestSubRegion"));
}
@Test
@SuppressWarnings("unchecked")
public void testLookupFallbackWithUnspecifiedPool() throws Exception {
public void configurePoolFromRegionAttributesAndEagerlyInitializesPool() {
BeanFactory mockBeanFactory = mock(BeanFactory.class);
ClientCache mockClientCache = mock(ClientCache.class);
ClientRegionFactory<Object, Object> mockClientRegionFactory = mock(ClientRegionFactory.class);
RegionAttributes<Object, Object> mockRegionAttributes = mock(RegionAttributes.class);
when(mockBeanFactory.containsBean(eq("TestPool"))).thenReturn(true);
when(mockBeanFactory.isTypeMatch(eq("TestPool"), eq(Pool.class))).thenReturn(true);
when(mockRegionAttributes.getPoolName()).thenReturn("TestPool");
factoryBean.setAttributes(mockRegionAttributes);
factoryBean.setBeanFactory(mockBeanFactory);
factoryBean.configure(mockClientRegionFactory);
verify(mockBeanFactory, times(1)).containsBean(eq("TestPool"));
verify(mockBeanFactory, times(1)).isTypeMatch(eq("TestPool"), eq(Pool.class));
verify(mockBeanFactory, times(1)).getBean(eq("TestPool"), eq(Pool.class));
verify(mockClientRegionFactory, times(1)).setPoolName(eq("TestPool"));
verify(mockRegionAttributes, times(1)).getPoolName();
}
@Test
@SuppressWarnings("unchecked")
public void configurePoolFromRegionAttributesThrowsExceptionWhileEagerlyInitializingPool() {
BeanFactory mockBeanFactory = mock(BeanFactory.class);
ClientRegionFactory<Object, Object> mockClientRegionFactory = mock(ClientRegionFactory.class);
Region<Object, Object> mockRegion = mock(Region.class);
RegionAttributes<Object, Object> mockRegionAttributes = mock(RegionAttributes.class);
when(mockBeanFactory.containsBean(eq("TestPool"))).thenReturn(true);
when(mockBeanFactory.isTypeMatch(eq("TestPool"), eq(Pool.class))).thenReturn(true);
when(mockBeanFactory.getBean(eq("TestPool"), eq(Pool.class)))
.thenThrow(new BeanCreationException("TEST"));
when(mockRegionAttributes.getPoolName()).thenReturn("TestPool");
factoryBean.setAttributes(mockRegionAttributes);
factoryBean.setBeanFactory(mockBeanFactory);
factoryBean.configure(mockClientRegionFactory);
verify(mockBeanFactory, times(1)).containsBean(eq("TestPool"));
verify(mockBeanFactory, times(1)).isTypeMatch(eq("TestPool"), eq(Pool.class));
verify(mockBeanFactory, times(1)).getBean(eq("TestPool"), eq(Pool.class));
verify(mockClientRegionFactory, times(1)).setPoolName(eq("TestPool"));
verify(mockRegionAttributes, times(1)).getPoolName();
}
@Test
@SuppressWarnings("unchecked")
public void configurePoolFromRegionAttributesDoesNotEagerlyInitializePoolWhenNotPoolTypeMatch() {
BeanFactory mockBeanFactory = mock(BeanFactory.class);
ClientRegionFactory<Object, Object> mockClientRegionFactory = mock(ClientRegionFactory.class);
RegionAttributes<Object, Object> mockRegionAttributes = mock(RegionAttributes.class);
when(mockBeanFactory.containsBean(eq("TestPool"))).thenReturn(true);
when(mockBeanFactory.isTypeMatch(eq("TestPool"), eq(Pool.class))).thenReturn(false);
when(mockRegionAttributes.getPoolName()).thenReturn("TestPool");
factoryBean.setAttributes(mockRegionAttributes);
factoryBean.setBeanFactory(mockBeanFactory);
factoryBean.configure(mockClientRegionFactory);
verify(mockBeanFactory, times(1)).containsBean(eq("TestPool"));
verify(mockBeanFactory, times(1)).isTypeMatch(eq("TestPool"), eq(Pool.class));
verify(mockBeanFactory, never()).getBean(anyString(), eq(Pool.class));
verify(mockClientRegionFactory, times(1)).setPoolName(eq("TestPool"));
verify(mockRegionAttributes, times(1)).getPoolName();
}
@Test
@SuppressWarnings("unchecked")
public void doesNotConfigurePoolFromRegionAttributesWhenPoolIsUnresolvable() {
BeanFactory mockBeanFactory = mock(BeanFactory.class);
ClientRegionFactory<Object, Object> mockClientRegionFactory = mock(ClientRegionFactory.class);
RegionAttributes<Object, Object> mockRegionAttributes = mock(RegionAttributes.class);
when(mockBeanFactory.containsBean(anyString())).thenReturn(false);
when(mockClientCache.createClientRegionFactory(eq(ClientRegionShortcut.LOCAL_HEAP_LRU))).thenReturn(mockClientRegionFactory);
when(mockClientRegionFactory.create(eq("TestRegion"))).thenReturn(mockRegion);
when(mockRegionAttributes.getPoolName()).thenReturn("TestPool");
factoryBean.setAttributes(null);
factoryBean.setAttributes(mockRegionAttributes);
factoryBean.setBeanFactory(mockBeanFactory);
factoryBean.setShortcut(ClientRegionShortcut.LOCAL_HEAP_LRU);
factoryBean.configure(mockClientRegionFactory);
Region<Object, Object> actualRegion = factoryBean.createRegion(mockClientCache, "TestRegion");
verify(mockBeanFactory, times(1)).containsBean(eq("TestPool"));
verify(mockBeanFactory, never()).isTypeMatch(anyString(), eq(Pool.class));
verify(mockBeanFactory, never()).getBean(anyString(), eq(Pool.class));
verify(mockClientRegionFactory, never()).setPoolName(anyString());
verify(mockRegionAttributes, times(1)).getPoolName();
}
assertSame(mockRegion, actualRegion);
@Test
@SuppressWarnings("unchecked")
public void doesNotConfigurePoolFromRegionAttributesWhenPoolIsDefaultPool() {
verify(mockBeanFactory, times(1)).containsBean(eq(GemfireConstants.DEFAULT_GEMFIRE_POOL_NAME));
verify(mockClientCache, times(1)).createClientRegionFactory(eq(ClientRegionShortcut.LOCAL_HEAP_LRU));
verify(mockClientRegionFactory, times(1)).create(eq("TestRegion"));
verify(mockClientRegionFactory, never()).setPoolName(any(String.class));
BeanFactory mockBeanFactory = mock(BeanFactory.class);
ClientRegionFactory<Object, Object> mockClientRegionFactory = mock(ClientRegionFactory.class);
RegionAttributes<Object, Object> mockRegionAttributes = mock(RegionAttributes.class);
when(mockRegionAttributes.getPoolName()).thenReturn(ClientRegionFactoryBean.DEFAULT_POOL_NAME);
factoryBean.setAttributes(mockRegionAttributes);
factoryBean.setBeanFactory(mockBeanFactory);
factoryBean.configure(mockClientRegionFactory);
verify(factoryBean, never()).isPoolResolvable(anyString());
verify(mockBeanFactory, never()).containsBean(anyString());
verify(mockBeanFactory, never()).isTypeMatch(anyString(), eq(Pool.class));
verify(mockBeanFactory, never()).getBean(anyString(), eq(Pool.class));
verify(mockClientRegionFactory, never()).setPoolName(anyString());
verify(mockRegionAttributes, times(1)).getPoolName();
}
@Test
@SuppressWarnings("unchecked")
public void doesNotConfigurePoolFromRegionAttributesWhenPoolIsEmpty() {
BeanFactory mockBeanFactory = mock(BeanFactory.class);
ClientRegionFactory<Object, Object> mockClientRegionFactory = mock(ClientRegionFactory.class);
RegionAttributes<Object, Object> mockRegionAttributes = mock(RegionAttributes.class);
when(mockRegionAttributes.getPoolName()).thenReturn(" ");
factoryBean.setAttributes(mockRegionAttributes);
factoryBean.setBeanFactory(mockBeanFactory);
factoryBean.configure(mockClientRegionFactory);
verify(factoryBean, never()).isNotDefaultPool(anyString());
verify(factoryBean, never()).isPoolResolvable(anyString());
verify(mockBeanFactory, never()).containsBean(anyString());
verify(mockBeanFactory, never()).isTypeMatch(anyString(), eq(Pool.class));
verify(mockBeanFactory, never()).getBean(anyString(), eq(Pool.class));
verify(mockClientRegionFactory, never()).setPoolName(anyString());
verify(mockRegionAttributes, times(1)).getPoolName();
}
@Test
@SuppressWarnings("unchecked")
public void doesNotConfigurePoolFromRegionAttributesWhenPoolIsNull() {
BeanFactory mockBeanFactory = mock(BeanFactory.class);
ClientRegionFactory<Object, Object> mockClientRegionFactory = mock(ClientRegionFactory.class);
RegionAttributes<Object, Object> mockRegionAttributes = mock(RegionAttributes.class);
when(mockRegionAttributes.getPoolName()).thenReturn(null);
factoryBean.setAttributes(mockRegionAttributes);
factoryBean.setBeanFactory(mockBeanFactory);
factoryBean.configure(mockClientRegionFactory);
verify(factoryBean, never()).isNotDefaultPool(anyString());
verify(factoryBean, never()).isPoolResolvable(anyString());
verify(mockBeanFactory, never()).containsBean(anyString());
verify(mockBeanFactory, never()).isTypeMatch(anyString(), eq(Pool.class));
verify(mockBeanFactory, never()).getBean(anyString(), eq(Pool.class));
verify(mockClientRegionFactory, never()).setPoolName(anyString());
verify(mockRegionAttributes, times(1)).getPoolName();
}
@Test
@SuppressWarnings("unchecked")
public void configurePoolFromClientRegionFactoryBeanAndEagerlyInitializesPool() {
BeanFactory mockBeanFactory = mock(BeanFactory.class);
ClientRegionFactory<Object, Object> mockClientRegionFactory = mock(ClientRegionFactory.class);
when(mockBeanFactory.containsBean(eq("MockPool"))).thenReturn(true);
when(mockBeanFactory.isTypeMatch(eq("MockPool"), eq(Pool.class))).thenReturn(true);
factoryBean.setBeanFactory(mockBeanFactory);
factoryBean.setPoolName("MockPool");
factoryBean.configure(mockClientRegionFactory);
verify(mockBeanFactory, times(1)).containsBean(eq("MockPool"));
verify(mockBeanFactory, times(1)).isTypeMatch(eq("MockPool"), eq(Pool.class));
verify(mockBeanFactory, times(1)).getBean(eq("MockPool"), eq(Pool.class));
verify(mockClientRegionFactory, times(1)).setPoolName(eq("MockPool"));
}
@Test
@SuppressWarnings("unchecked")
public void configurePoolFromClientRegionFactoryBeanThrowsExceptionWhileEagerlyInitializingPool() {
BeanFactory mockBeanFactory = mock(BeanFactory.class);
ClientRegionFactory<Object, Object> mockClientRegionFactory = mock(ClientRegionFactory.class);
when(mockBeanFactory.containsBean(eq("MockPool"))).thenReturn(true);
when(mockBeanFactory.isTypeMatch(eq("MockPool"), eq(Pool.class))).thenReturn(true);
when(mockBeanFactory.getBean(eq("MockPool"), eq(Pool.class))).thenThrow(new BeanCreationException("TEST"));
factoryBean.setBeanFactory(mockBeanFactory);
factoryBean.setPoolName("MockPool");
factoryBean.configure(mockClientRegionFactory);
verify(mockBeanFactory, times(1)).containsBean(eq("MockPool"));
verify(mockBeanFactory, times(1)).isTypeMatch(eq("MockPool"), eq(Pool.class));
verify(mockBeanFactory, times(1)).getBean(eq("MockPool"), eq(Pool.class));
verify(mockClientRegionFactory, times(1)).setPoolName(eq("MockPool"));
}
@Test
@SuppressWarnings("unchecked")
public void configurePoolFromClientRegionFactoryBeanDoesNotEagerlyInitializePoolWhenNotPoolTypeMatch() {
BeanFactory mockBeanFactory = mock(BeanFactory.class);
ClientRegionFactory<Object, Object> mockClientRegionFactory = mock(ClientRegionFactory.class);
when(mockBeanFactory.containsBean(eq("MockPool"))).thenReturn(true);
when(mockBeanFactory.isTypeMatch(anyString(), eq(Pool.class))).thenReturn(false);
factoryBean.setBeanFactory(mockBeanFactory);
factoryBean.setPoolName("MockPool");
factoryBean.configure(mockClientRegionFactory);
verify(mockBeanFactory, times(1)).containsBean(eq("MockPool"));
verify(mockBeanFactory, times(1)).isTypeMatch(eq("MockPool"), eq(Pool.class));
verify(mockBeanFactory, never()).getBean(anyString(), eq(Pool.class));
verify(mockClientRegionFactory, times(1)).setPoolName(eq("MockPool"));
}
@Test
@SuppressWarnings("unchecked")
public void configuresPoolFromClientRegionFactoryBeanEvenWhenRegionAttributesPoolNameIsSet() {
BeanFactory mockBeanFactory = mock(BeanFactory.class);
ClientRegionFactory<Object, Object> mockClientRegionFactory = mock(ClientRegionFactory.class);
RegionAttributes<Object, Object> mockRegionAttributes = mock(RegionAttributes.class);
when(mockBeanFactory.containsBean(anyString())).thenReturn(true);
when(mockBeanFactory.isTypeMatch(anyString(), eq(Pool.class))).thenReturn(true);
when(mockRegionAttributes.getPoolName()).thenReturn("TestPool");
factoryBean.setAttributes(mockRegionAttributes);
factoryBean.setBeanFactory(mockBeanFactory);
factoryBean.setPoolName("MockPool");
factoryBean.configure(mockClientRegionFactory);
InOrder inOrderVerifier = inOrder(mockBeanFactory, mockClientRegionFactory);
inOrderVerifier.verify(mockBeanFactory, times(1)).containsBean(eq("TestPool"));
inOrderVerifier.verify(mockBeanFactory, times(1)).isTypeMatch(eq("TestPool"), eq(Pool.class));
inOrderVerifier.verify(mockBeanFactory, times(1)).getBean(eq("TestPool"), eq(Pool.class));
inOrderVerifier.verify(mockClientRegionFactory, times(1)).setPoolName(eq("TestPool"));
inOrderVerifier.verify(mockBeanFactory, times(1)).containsBean(eq("MockPool"));
inOrderVerifier.verify(mockBeanFactory, times(1)).isTypeMatch(eq("MockPool"), eq(Pool.class));
inOrderVerifier.verify(mockBeanFactory, times(1)).getBean(eq("MockPool"), eq(Pool.class));
inOrderVerifier.verify(mockClientRegionFactory, times(1)).setPoolName(eq("MockPool"));
}
@Test
@SuppressWarnings("unchecked")
public void doesNotConfigurePoolFromClientRegionFactoryBeanWhenPoolIsUnresolvable() {
BeanFactory mockBeanFactory = mock(BeanFactory.class);
ClientRegionFactory<Object, Object> mockClientRegionFactory = mock(ClientRegionFactory.class);
when(mockBeanFactory.containsBean(anyString())).thenReturn(false);
factoryBean.setBeanFactory(mockBeanFactory);
factoryBean.setPoolName("MockPool");
factoryBean.configure(mockClientRegionFactory);
verify(mockBeanFactory, times(1)).containsBean(eq("MockPool"));
verify(mockBeanFactory, never()).isTypeMatch(anyString(), eq(Pool.class));
verify(mockBeanFactory, never()).getBean(anyString(), eq(Pool.class));
verify(mockClientRegionFactory, never()).setPoolName(anyString());
}
@Test
@SuppressWarnings("unchecked")
public void doesNotConfigurePoolFromClientRegionFactoryBeanWhenPoolIsDefaultPool() {
BeanFactory mockBeanFactory = mock(BeanFactory.class);
ClientRegionFactory<Object, Object> mockClientRegionFactory = mock(ClientRegionFactory.class);
factoryBean.setBeanFactory(mockBeanFactory);
factoryBean.setPoolName(ClientRegionFactoryBean.DEFAULT_POOL_NAME);
factoryBean.configure(mockClientRegionFactory);
verify(factoryBean, never()).isPoolResolvable(anyString());
verify(mockBeanFactory, never()).containsBean(anyString());
verify(mockBeanFactory, never()).isTypeMatch(anyString(), eq(Pool.class));
verify(mockBeanFactory, never()).getBean(anyString(), eq(Pool.class));
verify(mockClientRegionFactory, never()).setPoolName(anyString());
}
@Test
@SuppressWarnings("unchecked")
public void doesNotConfigurePoolFromClientRegionFactoryBeanWhenPoolIsEmpty() {
BeanFactory mockBeanFactory = mock(BeanFactory.class);
ClientRegionFactory<Object, Object> mockClientRegionFactory = mock(ClientRegionFactory.class);
factoryBean.setBeanFactory(mockBeanFactory);
factoryBean.setPoolName("");
factoryBean.configure(mockClientRegionFactory);
verify(factoryBean, never()).isNotDefaultPool(anyString());
verify(factoryBean, never()).isPoolResolvable(anyString());
verify(mockBeanFactory, never()).containsBean(anyString());
verify(mockBeanFactory, never()).isTypeMatch(anyString(), eq(Pool.class));
verify(mockBeanFactory, never()).getBean(anyString(), eq(Pool.class));
verify(mockClientRegionFactory, never()).setPoolName(anyString());
}
@Test
@SuppressWarnings("unchecked")
public void doesNotConfigurePoolFromClientRegionFactoryBeanWhenPoolIsNull() {
BeanFactory mockBeanFactory = mock(BeanFactory.class);
ClientRegionFactory<Object, Object> mockClientRegionFactory = mock(ClientRegionFactory.class);
factoryBean.setBeanFactory(mockBeanFactory);
factoryBean.setPoolName(null);
factoryBean.configure(mockClientRegionFactory);
verify(factoryBean, never()).isNotDefaultPool(anyString());
verify(factoryBean, never()).isPoolResolvable(anyString());
verify(mockBeanFactory, never()).containsBean(anyString());
verify(mockBeanFactory, never()).isTypeMatch(anyString(), eq(Pool.class));
verify(mockBeanFactory, never()).getBean(anyString(), eq(Pool.class));
verify(mockClientRegionFactory, never()).setPoolName(anyString());
}
@Test
@SuppressWarnings("deprecation")
public void testSetDataPolicyName() throws Exception {
public void setDataPolicyName() throws Exception {
factoryBean.setDataPolicyName("NORMAL");
assertEquals(DataPolicy.NORMAL, TestUtils.readField("dataPolicy", factoryBean));
}
@Test(expected = IllegalArgumentException.class)
@SuppressWarnings("deprecation")
public void testSetDataPolicyNameWithInvalidName() throws Exception {
public void setDataPolicyNameWithInvalidName() throws Exception {
try {
factoryBean.setDataPolicyName("INVALID");
}
catch (IllegalArgumentException expected) {
assertEquals("Data Policy [INVALID] is not valid", expected.getMessage());
assertThat(expected).hasMessage("Data Policy [INVALID] is not valid");
assertThat(expected).hasNoCause();
throw expected;
}
finally {
@@ -327,34 +653,46 @@ public class ClientRegionFactoryBeanTest {
}
@Test
public void testIsPersistent() {
public void isPersistentIsCorrect() {
assertFalse(factoryBean.isPersistent());
factoryBean.setPersistent(false);
assertFalse(factoryBean.isPersistent());
factoryBean.setPersistent(true);
assertTrue(factoryBean.isPersistent());
}
@Test
public void testIsPersistentUnspecified() {
public void isPersistentUnspecifiedIsCorrect() {
assertTrue(factoryBean.isPersistentUnspecified());
factoryBean.setPersistent(true);
assertTrue(factoryBean.isPersistent());
assertFalse(factoryBean.isPersistentUnspecified());
factoryBean.setPersistent(false);
assertTrue(factoryBean.isNotPersistent());
assertFalse(factoryBean.isPersistentUnspecified());
}
@Test
public void testIsNotPersistent() {
public void isNotPersistentIsCorrect() {
assertFalse(factoryBean.isNotPersistent());
factoryBean.setPersistent(true);
assertFalse(factoryBean.isNotPersistent());
factoryBean.setPersistent(false);
assertTrue(factoryBean.isNotPersistent());
}
@@ -597,7 +935,7 @@ public class ClientRegionFactoryBeanTest {
assertEquals(ClientRegionShortcut.LOCAL_PERSISTENT, factoryBean.resolveClientRegionShortcut());
}
protected <K> Interest<K> newInterest(K key) {
private <K> Interest<K> newInterest(K key) {
return new Interest<>(key);
}
@@ -612,22 +950,19 @@ public class ClientRegionFactoryBeanTest {
when(mockRegion.getRegionService()).thenReturn(mockRegionService);
when(mockRegionService.isClosed()).thenReturn(false);
ClientRegionFactoryBean clientRegionFactoryBean = new ClientRegionFactoryBean() {
@Override public Region getObject() throws Exception {
return mockRegion;
}
};
doReturn(mockRegion).when(factoryBean).getObject();
clientRegionFactoryBean.setClose(true);
clientRegionFactoryBean.setInterests(ArrayUtils.asArray(newInterest("test")));
factoryBean.setClose(true);
factoryBean.setInterests(ArrayUtils.asArray(newInterest("test")));
assertThat(clientRegionFactoryBean.isClose(), is(true));
assertThat(clientRegionFactoryBean.isDestroy(), is(false));
assertThat(clientRegionFactoryBean.getInterests(), is(notNullValue()));
assertThat(clientRegionFactoryBean.getInterests().length, is(equalTo(1)));
assertThat(factoryBean.isClose()).isTrue();
assertThat(factoryBean.isDestroy()).isFalse();
assertThat(factoryBean.getInterests()).isNotNull();
assertThat(factoryBean.getInterests()).hasSize(1);
clientRegionFactoryBean.destroy();
factoryBean.destroy();
verify(factoryBean, times(1)).getObject();
verify(mockRegion, times(1)).getRegionService();
verify(mockRegionService, times(1)).isClosed();
verify(mockRegion, times(1)).close();
@@ -647,23 +982,20 @@ public class ClientRegionFactoryBeanTest {
when(mockRegion.getRegionService()).thenReturn(mockRegionService);
when(mockRegionService.isClosed()).thenReturn(false);
ClientRegionFactoryBean clientRegionFactoryBean = new ClientRegionFactoryBean() {
@Override public Region getObject() throws Exception {
return mockRegion;
}
};
doReturn(mockRegion).when(factoryBean).getObject();
clientRegionFactoryBean.setClose(false);
clientRegionFactoryBean.setDestroy(true);
clientRegionFactoryBean.setInterests(ArrayUtils.asArray(newInterest("test")));
factoryBean.setClose(false);
factoryBean.setDestroy(true);
factoryBean.setInterests(ArrayUtils.asArray(newInterest("test")));
assertThat(clientRegionFactoryBean.isClose(), is(false));
assertThat(clientRegionFactoryBean.isDestroy(), is(true));
assertThat(clientRegionFactoryBean.getInterests(), is(notNullValue()));
assertThat(clientRegionFactoryBean.getInterests().length, is(equalTo(1)));
assertThat(factoryBean.isClose()).isFalse();
assertThat(factoryBean.isDestroy()).isTrue();
assertThat(factoryBean.getInterests()).isNotNull();
assertThat(factoryBean.getInterests()).hasSize(1);
clientRegionFactoryBean.destroy();
factoryBean.destroy();
verify(factoryBean, times(1)).getObject();
verify(mockRegion, never()).getRegionService();
verify(mockRegionService, never()).isClosed();
verify(mockRegion, never()).close();
@@ -683,22 +1015,19 @@ public class ClientRegionFactoryBeanTest {
when(mockRegion.getRegionService()).thenReturn(mockRegionService);
when(mockRegionService.isClosed()).thenReturn(true);
ClientRegionFactoryBean clientRegionFactoryBean = new ClientRegionFactoryBean() {
@Override public Region getObject() throws Exception {
return mockRegion;
}
};
doReturn(mockRegion).when(factoryBean).getObject();
clientRegionFactoryBean.setClose(true);
clientRegionFactoryBean.setInterests(ArrayUtils.asArray(newInterest("test")));
factoryBean.setClose(true);
factoryBean.setInterests(ArrayUtils.asArray(newInterest("test")));
assertThat(clientRegionFactoryBean.isClose(), is(true));
assertThat(clientRegionFactoryBean.isDestroy(), is(false));
assertThat(clientRegionFactoryBean.getInterests(), is(notNullValue()));
assertThat(clientRegionFactoryBean.getInterests().length, is(equalTo(1)));
assertThat(factoryBean.isClose()).isTrue();
assertThat(factoryBean.isDestroy()).isFalse();
assertThat(factoryBean.getInterests()).isNotNull();
assertThat(factoryBean.getInterests()).hasSize(1);
clientRegionFactoryBean.destroy();
factoryBean.destroy();
verify(factoryBean, times(1)).getObject();
verify(mockRegion, times(1)).getRegionService();
verify(mockRegionService, times(1)).isClosed();
verify(mockRegion, never()).close();
@@ -713,14 +1042,11 @@ public class ClientRegionFactoryBeanTest {
Region mockRegion = mock(Region.class, "MockRegion");
ClientRegionFactoryBean clientRegionFactoryBean = new ClientRegionFactoryBean() {
@Override public Region getObject() throws Exception {
return mockRegion;
}
};
doReturn(mockRegion).when(factoryBean).getObject();
clientRegionFactoryBean.destroy();
factoryBean.destroy();
verify(factoryBean, times(1)).getObject();
verify(mockRegion, never()).getRegionService();
verify(mockRegion, never()).close();
verify(mockRegion, never()).destroyRegion();
@@ -731,12 +1057,10 @@ public class ClientRegionFactoryBeanTest {
@Test
public void destroyDoesNothingWhenRegionIsNull() throws Exception {
ClientRegionFactoryBean clientRegionFactoryBean = new ClientRegionFactoryBean() {
@Override public Region getObject() throws Exception {
return null;
}
};
doReturn(null).when(factoryBean).getObject();
clientRegionFactoryBean.destroy();
factoryBean.destroy();
verify(factoryBean, times(1)).getObject();
}
}

142
src/test/java/org/springframework/data/gemfire/client/LocalOnlyClientCacheIntegrationTest.java
View File

@@ -1,142 +0,0 @@
/*
* Copyright 2012 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.springframework.data.gemfire.client;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.notNullValue;
import static org.hamcrest.Matchers.nullValue;
import static org.junit.Assert.assertThat;
import java.util.Properties;
import javax.annotation.Resource;
import org.apache.geode.cache.DataPolicy;
import org.apache.geode.cache.GemFireCache;
import org.apache.geode.cache.Region;
import org.apache.geode.cache.RegionAttributes;
import org.apache.geode.cache.client.ClientRegionShortcut;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
import org.springframework.data.gemfire.RegionAttributesFactoryBean;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;
/**
* The LocalOnlyClientCacheIntegrationTest class...
*
* @author John Blum
* @since 1.0.0
*/
@RunWith(SpringRunner.class)
@ContextConfiguration
@SuppressWarnings("unused")
public class LocalOnlyClientCacheIntegrationTest {
@Resource(name = "Example")
private Region<Long, String> example;
@Before
public void assertRegionDetails() {
assertThat(example, is(notNullValue()));
assertThat(example.getName(), is(equalTo("Example")));
assertThat(example.getFullPath(), is(equalTo(String.format("%1$sExample", Region.SEPARATOR))));
assertThat(example.getAttributes(), is(notNullValue()));
assertThat(example.getAttributes().getDataPolicy(), is(equalTo(DataPolicy.NORMAL)));
assertThat(example.getAttributes().getKeyConstraint(), is(equalTo(Long.class)));
assertThat(example.getAttributes().getValueConstraint(), is(equalTo(String.class)));
}
@Test
public void getAndPutsAreSuccessful() {
assertThat(example.put(1L, "one"), is(nullValue()));
assertThat(example.put(2L, "two"), is(nullValue()));
assertThat(example.put(3L, "three"), is(nullValue()));
assertThat(example.get(1L), is(equalTo("one")));
assertThat(example.get(2L), is(equalTo("two")));
assertThat(example.get(3L), is(equalTo("three")));
assertThat(example.get(0L), is(nullValue()));
assertThat(example.get(4L), is(nullValue()));
}
@Configuration
static class GemFireClientCacheConfiguration {
@Bean
static PropertySourcesPlaceholderConfigurer propertyPlaceholderConfigurer() {
return new PropertySourcesPlaceholderConfigurer();
}
@Bean
Properties gemfireProperties(@Value("${spring.data.gemfire.log.level:warning}") String logLevel) {
Properties gemfireProperties = new Properties();
gemfireProperties.setProperty("name", LocalOnlyClientCacheIntegrationTest.class.getSimpleName());
gemfireProperties.setProperty("log-level", logLevel);
return gemfireProperties;
}
@Bean
ClientCacheFactoryBean gemfireCache(@Qualifier("gemfireProperties") Properties gemfireProperties) {
ClientCacheFactoryBean gemfireCache = new ClientCacheFactoryBean();
gemfireCache.setClose(true);
gemfireCache.setProperties(gemfireProperties);
gemfireCache.setUseBeanFactoryLocator(false);
return gemfireCache;
}
@Bean(name = "Example")
ClientRegionFactoryBean<Long, String> exampleRegion(GemFireCache gemfireCache,
RegionAttributes<Long, String> exampleAttributes) {
ClientRegionFactoryBean<Long, String> exampleRegion = new ClientRegionFactoryBean<>();
exampleRegion.setCache(gemfireCache);
exampleRegion.setAttributes(exampleAttributes);
exampleRegion.setName("Example");
exampleRegion.setPersistent(false);
exampleRegion.setShortcut(ClientRegionShortcut.LOCAL);
return exampleRegion;
}
@Bean
@SuppressWarnings("unchecked")
RegionAttributesFactoryBean exampleRegionAttributes() {
RegionAttributesFactoryBean exampleRegionAttributes = new RegionAttributesFactoryBean();
exampleRegionAttributes.setKeyConstraint(Long.class);
exampleRegionAttributes.setValueConstraint(String.class);
return exampleRegionAttributes;
}
}
}

88
src/test/java/org/springframework/data/gemfire/client/LocalOnlyClientCacheIntegrationTests.java Normal file
View File

@@ -0,0 +1,88 @@
/*
* Copyright 2012 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.springframework.data.gemfire.client;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.Calendar;
import javax.annotation.Resource;
import org.apache.geode.cache.DataPolicy;
import org.apache.geode.cache.Region;
import org.apache.geode.cache.client.ClientCache;
import org.apache.geode.cache.client.ClientRegionShortcut;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.data.gemfire.GemfireUtils;
import org.springframework.data.gemfire.config.annotation.ClientCacheApplication;
import org.springframework.data.gemfire.config.annotation.EnableEntityDefinedRegions;
import org.springframework.data.gemfire.test.model.Gender;
import org.springframework.data.gemfire.test.model.Person;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;
/**
* Integration tests testing the configuration of a {@link ClientRegionShortcut#LOCAL}
* {@link ClientCache} {@link Region}.
*
* @author John Blum
* @see org.junit.Test
* @since 1.6.3
*/
@RunWith(SpringRunner.class)
@ContextConfiguration
@SuppressWarnings("unused")
public class LocalOnlyClientCacheIntegrationTests {
@Resource(name = "People")
private Region<Long, Person> people;
@Before
public void assertPeopleRegionConfiguration() {
assertThat(this.people).isNotNull();
assertThat(this.people.getName()).isEqualTo("People");
assertThat(this.people.getFullPath()).isEqualTo(GemfireUtils.toRegionPath("People"));
assertThat(this.people.getAttributes()).isNotNull();
assertThat(this.people.getAttributes().getDataPolicy()).isEqualTo(DataPolicy.NORMAL);
assertThat(this.people.getAttributes().getKeyConstraint()).isEqualTo(Long.class);
assertThat(this.people.getAttributes().getValueConstraint()).isEqualTo(Person.class);
assertThat(this.people).hasSize(0);
}
@Test
public void putAndGetPersonIsSuccessful() {
Person jonDoe = Person.newPerson("Jon", "Doe",
Person.newBirthDate(1974, Calendar.MAY, 5), Gender.MALE);
assertThat(this.people).hasSize(0);
assertThat(this.people.put(jonDoe.getId(), jonDoe));
assertThat(this.people).hasSize(1);
assertThat(this.people.get(jonDoe.getId())).isEqualTo(jonDoe);
assertThat(this.people).hasSize(1);
}
@ClientCacheApplication
@EnableEntityDefinedRegions(basePackageClasses = Person.class,
clientRegionShortcut = ClientRegionShortcut.LOCAL, strict = true)
static class GemFireClientCacheConfiguration {
}
}

17
src/test/java/org/springframework/data/gemfire/function/config/FunctionExecutionClientCacheTests.java
View File

@@ -13,6 +13,8 @@
package org.springframework.data.gemfire.function.config;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import java.util.concurrent.TimeUnit;
@@ -48,19 +50,24 @@ public class FunctionExecutionClientCacheTests {
@Test
public void contextCreated() throws Exception {
ClientCache cache = applicationContext.getBean("gemfireCache", ClientCache.class);
Pool pool = applicationContext.getBean("gemfirePool", Pool.class);
ClientCache cache = this.applicationContext.getBean("gemfireCache", ClientCache.class);
Pool pool = this.applicationContext.getBean("gemfirePool", Pool.class);
assertEquals("gemfirePool", pool.getName());
assertTrue(cache.getDefaultPool().getLocators().isEmpty());
assertEquals(1, cache.getDefaultPool().getServers().size());
assertTrue(pool.getLocators().isEmpty());
assertEquals(1, pool.getServers().size());
assertEquals(pool.getServers().get(0), cache.getDefaultPool().getServers().get(0));
Region region = applicationContext.getBean("r1", Region.class);
Region region = this.applicationContext.getBean("r1", Region.class);
assertEquals("gemfirePool", region.getAttributes().getPoolName());
assertEquals("r1", region.getName());
assertNotNull(region.getAttributes());
assertNull(region.getAttributes().getPoolName());
GemfireOnServerFunctionTemplate template = applicationContext.getBean(GemfireOnServerFunctionTemplate.class);
GemfireOnServerFunctionTemplate template = this.applicationContext.getBean(GemfireOnServerFunctionTemplate.class);
assertTrue(template.getResultCollector() instanceof MyResultCollector);
}