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

SGF-414 - Resolve incompatibility between the DistributedSystem created by the PoolFactoryBean and the DistributedSystem resolved by the ClientCacheFactoryBean when SSL is configured.

Browse Source 
(cherry picked from commit 130cc4ca4c84a0151ba8f98194a3522ac7e34121)

Signed-off-by: John Blum <jblum@pivotal.io>

Added additional test cases for the CacheFactoryBean and ClientCacheFactoryBean based on SSL support. 1.7 SDG XSD cleanup.
This commit is contained in:
John Blum
2015-07-10 16:56:29 -07:00
parent 82334090fe
commit 3b85b723d8
4 changed files with 413 additions and 141 deletions
Download Patch File Download Diff File Expand all files Collapse all files

306
src/test/java/org/springframework/data/gemfire/CacheFactoryBeanTest.java
View File

@@ -22,7 +22,6 @@ import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.junit.Assume.assumeTrue;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Matchers.eq;
@@ -71,7 +70,7 @@ import com.gemstone.gemfire.pdx.PdxSerializer;
public class CacheFactoryBeanTest {
@Test
public void testAfterPropertiesSet() throws Exception {
public void afterPropertiesSet() throws Exception {
BeanFactory mockBeanFactory = mock(BeanFactory.class, "SpringBeanFactory");
Cache mockCache = mock(Cache.class, "GemFireCache");
CacheTransactionManager mockCacheTransactionManager = mock(CacheTransactionManager.class, "GemFireTransactionManager");
@@ -178,98 +177,7 @@ public class CacheFactoryBeanTest {
}
@Test
public void testFetchExistingCache() throws Exception {
Cache mockCache = mock(Cache.class, "GemFireCache");
CacheFactoryBean cacheFactoryBean = new CacheFactoryBean();
ReflectionUtils.setField(CacheFactoryBean.class.getDeclaredField("cache"), cacheFactoryBean, mockCache);
Cache actualCache = cacheFactoryBean.resolveCache();
assertSame(mockCache, actualCache);
}
@Test
public void testCreateWhenCacheExists() throws Exception {
Cache mockCache = mock(Cache.class, "GemFireCache");
CacheFactoryBean cacheFactoryBean = new CacheFactoryBean();
ReflectionUtils.setField(CacheFactoryBean.class.getDeclaredField("cache"), cacheFactoryBean, mockCache);
GemFireCache actualCache = cacheFactoryBean.createCache(null);
assertSame(mockCache, actualCache);
}
@Test
public void testCreateFactory() {
Properties gemfireProperties = new Properties();
Object cacheFactoryReference = new CacheFactoryBean().createFactory(gemfireProperties);
assertTrue(gemfireProperties.isEmpty());
assertTrue(cacheFactoryReference instanceof CacheFactory);
CacheFactory cacheFactory = (CacheFactory) cacheFactoryReference;
cacheFactory.set("name", "TestCreateCacheFactory");
assertTrue(gemfireProperties.containsKey("name"));
assertEquals("TestCreateCacheFactory", gemfireProperties.getProperty("name"));
}
@Test
public void testPrepareFactory() {
CacheFactoryBean cacheFactoryBean = new CacheFactoryBean();
cacheFactoryBean.setPdxSerializer(mock(PdxSerializer.class, "MockGemFirePdxSerializer"));
cacheFactoryBean.setPdxReadSerialized(true);
cacheFactoryBean.setPdxIgnoreUnreadFields(false);
CacheFactory mockCacheFactory = mock(CacheFactory.class, "MockGemFireCacheFactory");
cacheFactoryBean.prepareFactory(mockCacheFactory);
verify(mockCacheFactory, times(1)).setPdxSerializer(any(PdxSerializer.class));
verify(mockCacheFactory, never()).setPdxDiskStore(any(String.class));
verify(mockCacheFactory, times(1)).setPdxIgnoreUnreadFields(eq(false));
verify(mockCacheFactory, never()).setPdxPersistent(any(Boolean.class));
verify(mockCacheFactory, times(1)).setPdxReadSerialized(eq(true));
}
@Test(expected = IllegalArgumentException.class)
public void testPostProcessCacheWithInvalidCriticalHeapPercentage() throws Exception {
try {
CacheFactoryBean cacheFactoryBean = new CacheFactoryBean();
cacheFactoryBean.setCriticalHeapPercentage(200.0f);
cacheFactoryBean.postProcess(null);
}
catch (IllegalArgumentException expected) {
assertEquals("'criticalHeapPercentage' (200.0) is invalid; must be > 0.0 and <= 100.0",
expected.getMessage());
throw expected;
}
}
@Test(expected = IllegalArgumentException.class)
public void testPostProcessCacheWithInvalidEvictionHeapPercentage() throws Exception {
try {
CacheFactoryBean cacheFactoryBean = new CacheFactoryBean();
cacheFactoryBean.setEvictionHeapPercentage(-75.0f);
cacheFactoryBean.postProcess(null);
}
catch (IllegalArgumentException expected) {
assertEquals("'evictionHeapPercentage' (-75.0) is invalid; must be > 0.0 and <= 100.0",
expected.getMessage());
throw expected;
}
}
@Test
public void testPostProcessPropertiesBeforeInitializationDefaults() {
public void postProcessPropertiesBeforeInitializationDefaults() {
Properties gemfireProperties = new Properties();
assertTrue(gemfireProperties.isEmpty());
@@ -286,7 +194,7 @@ public class CacheFactoryBeanTest {
}
@Test
public void testPostProcessPropertiesBeforeInitializationDisabled() {
public void postProcessPropertiesBeforeInitializationDisabled() {
Properties gemfireProperties = new Properties();
assertTrue(gemfireProperties.isEmpty());
@@ -305,7 +213,7 @@ public class CacheFactoryBeanTest {
}
@Test
public void testPostProcessPropertiesBeforeInitializationEnabled() {
public void postProcessPropertiesBeforeInitializationEnabled() {
Properties gemfireProperties = new Properties();
assertTrue(gemfireProperties.isEmpty());
@@ -324,7 +232,185 @@ public class CacheFactoryBeanTest {
}
@Test
public void testGetObject() throws Exception {
public void fetchExistingCache() throws Exception {
Cache mockCache = mock(Cache.class, "GemFireCache");
CacheFactoryBean cacheFactoryBean = new CacheFactoryBean();
ReflectionUtils.setField(CacheFactoryBean.class.getDeclaredField("cache"), cacheFactoryBean, mockCache);
Cache actualCache = cacheFactoryBean.resolveCache();
assertSame(mockCache, actualCache);
}
@Test
public void resolveProperties() {
Properties gemfireProperties = new Properties();
CacheFactoryBean cacheFactoryBean = new CacheFactoryBean();
cacheFactoryBean.setProperties(gemfireProperties);
assertSame(gemfireProperties, cacheFactoryBean.resolveProperties());
}
@Test
public void createFactory() {
Properties gemfireProperties = new Properties();
Object cacheFactoryReference = new CacheFactoryBean().createFactory(gemfireProperties);
assertTrue(gemfireProperties.isEmpty());
assertTrue(cacheFactoryReference instanceof CacheFactory);
CacheFactory cacheFactory = (CacheFactory) cacheFactoryReference;
cacheFactory.set("name", "TestCreateCacheFactory");
assertTrue(gemfireProperties.containsKey("name"));
assertEquals("TestCreateCacheFactory", gemfireProperties.getProperty("name"));
}
@Test
public void prepareFactoryWithUnspecifiedPdxOptions() {
CacheFactory mockCacheFactory = mock(CacheFactory.class, "MockGemFireCacheFactory");
assertSame(mockCacheFactory, new CacheFactoryBean().prepareFactory(mockCacheFactory));
verify(mockCacheFactory, never()).setPdxSerializer(any(PdxSerializer.class));
verify(mockCacheFactory, never()).setPdxDiskStore(any(String.class));
verify(mockCacheFactory, never()).setPdxIgnoreUnreadFields(any(Boolean.class));
verify(mockCacheFactory, never()).setPdxPersistent(any(Boolean.class));
verify(mockCacheFactory, never()).setPdxReadSerialized(any(Boolean.class));
}
@Test
public void prepareFactoryWithPartialPdxOptions() {
CacheFactoryBean cacheFactoryBean = new CacheFactoryBean();
cacheFactoryBean.setPdxSerializer(mock(PdxSerializer.class, "MockGemFirePdxSerializer"));
cacheFactoryBean.setPdxReadSerialized(true);
cacheFactoryBean.setPdxIgnoreUnreadFields(false);
CacheFactory mockCacheFactory = mock(CacheFactory.class, "MockGemFireCacheFactory");
assertSame(mockCacheFactory, cacheFactoryBean.prepareFactory(mockCacheFactory));
verify(mockCacheFactory, times(1)).setPdxSerializer(any(PdxSerializer.class));
verify(mockCacheFactory, never()).setPdxDiskStore(any(String.class));
verify(mockCacheFactory, times(1)).setPdxIgnoreUnreadFields(eq(false));
verify(mockCacheFactory, never()).setPdxPersistent(any(Boolean.class));
verify(mockCacheFactory, times(1)).setPdxReadSerialized(eq(true));
}
@Test
public void prepareFactoryWithAllPdxOptions() {
CacheFactoryBean cacheFactoryBean = new CacheFactoryBean();
cacheFactoryBean.setPdxSerializer(mock(PdxSerializer.class, "MockGemFirePdxSerializer"));
cacheFactoryBean.setPdxDiskStoreName("testPdxDiskStoreName");
cacheFactoryBean.setPdxIgnoreUnreadFields(false);
cacheFactoryBean.setPdxPersistent(true);
cacheFactoryBean.setPdxReadSerialized(true);
CacheFactory mockCacheFactory = mock(CacheFactory.class, "MockGemFireCacheFactory");
assertSame(mockCacheFactory, cacheFactoryBean.prepareFactory(mockCacheFactory));
verify(mockCacheFactory, times(1)).setPdxSerializer(any(PdxSerializer.class));
verify(mockCacheFactory, times(1)).setPdxDiskStore(eq("testPdxDiskStoreName"));
verify(mockCacheFactory, times(1)).setPdxIgnoreUnreadFields(eq(false));
verify(mockCacheFactory, times(1)).setPdxPersistent(eq(true));
verify(mockCacheFactory, times(1)).setPdxReadSerialized(eq(true));
}
@Test(expected = IllegalArgumentException.class)
public void prepareFactoryWithInvalidTypeForPdxSerializer() {
CacheFactory mockCacheFactory = mock(CacheFactory.class, "MockGemFireCacheFactory");
try {
CacheFactoryBean cacheFactoryBean = new CacheFactoryBean();
cacheFactoryBean.setPdxSerializer(new Object());
cacheFactoryBean.setPdxIgnoreUnreadFields(false);
cacheFactoryBean.setPdxReadSerialized(true);
cacheFactoryBean.prepareFactory(mockCacheFactory);
}
catch (IllegalArgumentException expected) {
assertTrue(expected.getMessage().startsWith("Invalid pdx serializer used"));
assertNull(expected.getCause());
throw expected;
}
finally {
verify(mockCacheFactory, never()).setPdxSerializer(any(PdxSerializer.class));
verify(mockCacheFactory, never()).setPdxDiskStore(any(String.class));
verify(mockCacheFactory, never()).setPdxIgnoreUnreadFields(any(Boolean.class));
verify(mockCacheFactory, never()).setPdxPersistent(any(Boolean.class));
verify(mockCacheFactory, never()).setPdxReadSerialized(any(Boolean.class));
}
}
@Test
public void createCacheWithExistingCache() throws Exception {
Cache mockCache = mock(Cache.class, "MockGemFireCache");
CacheFactoryBean cacheFactoryBean = new CacheFactoryBean();
ReflectionUtils.setField(CacheFactoryBean.class.getDeclaredField("cache"), cacheFactoryBean, mockCache);
GemFireCache actualCache = cacheFactoryBean.createCache(null);
assertSame(mockCache, actualCache);
}
@Test
public void createCacheWithNoExistingCache() {
Cache mockCache = mock(Cache.class, "MockGemFireCache");
CacheFactory mockCacheFactory = mock(CacheFactory.class, "MockGemFireCacheFactory");
when(mockCacheFactory.create()).thenReturn(mockCache);
CacheFactoryBean cacheFactoryBean = new CacheFactoryBean();
Cache actualCache = cacheFactoryBean.createCache(mockCacheFactory);
assertSame(mockCache, actualCache);
verify(mockCacheFactory, times(1)).create();
}
@Test(expected = IllegalArgumentException.class)
public void postProcessCacheWithInvalidCriticalHeapPercentage() throws Exception {
try {
CacheFactoryBean cacheFactoryBean = new CacheFactoryBean();
cacheFactoryBean.setCriticalHeapPercentage(200.0f);
cacheFactoryBean.postProcess(null);
}
catch (IllegalArgumentException expected) {
assertEquals("'criticalHeapPercentage' (200.0) is invalid; must be > 0.0 and <= 100.0",
expected.getMessage());
throw expected;
}
}
@Test(expected = IllegalArgumentException.class)
public void postProcessCacheWithInvalidEvictionHeapPercentage() throws Exception {
try {
CacheFactoryBean cacheFactoryBean = new CacheFactoryBean();
cacheFactoryBean.setEvictionHeapPercentage(-75.0f);
cacheFactoryBean.postProcess(null);
}
catch (IllegalArgumentException expected) {
assertEquals("'evictionHeapPercentage' (-75.0) is invalid; must be > 0.0 and <= 100.0",
expected.getMessage());
throw expected;
}
}
@Test
public void getObject() throws Exception {
final ClassLoader expectedThreadContextClassLoader = Thread.currentThread().getContextClassLoader();
final Cache mockCache = mock(Cache.class, "GemFireCache");
@@ -341,9 +427,9 @@ public class CacheFactoryBeanTest {
when(mockDistributedMember.getProcessId()).thenReturn(67890);
CacheFactoryBean cacheFactoryBean = new CacheFactoryBean() {
@Override protected GemFireCache fetchCache() {
@Override @SuppressWarnings("unchecked") protected <T extends GemFireCache> T fetchCache() {
assertSame(ClassLoader.getSystemClassLoader(), getBeanClassLoader());
return mockCache;
return (T) mockCache;
}
};
@@ -371,17 +457,17 @@ public class CacheFactoryBeanTest {
}
@Test
public void testGetObjectType() {
public void getObjectType() {
assertEquals(Cache.class, new CacheFactoryBean().getObjectType());
}
@Test
public void testIsSingleton() {
public void isSingleton() {
assertTrue(new CacheFactoryBean().isSingleton());
}
@Test
public void testDestroy() throws Exception {
public void destroy() throws Exception {
final Cache mockCache = mock(Cache.class, "GemFireCache");
GemfireBeanFactoryLocator mockGemfireBeanFactoryLocator = mock(GemfireBeanFactoryLocator.class);
@@ -389,8 +475,8 @@ public class CacheFactoryBeanTest {
when(mockCache.isClosed()).thenReturn(false);
CacheFactoryBean cacheFactoryBean = new CacheFactoryBean() {
@Override protected GemFireCache fetchCache() {
return mockCache;
@Override @SuppressWarnings("unchecked") protected <T extends GemFireCache> T fetchCache() {
return (T) mockCache;
}
};
@@ -407,11 +493,11 @@ public class CacheFactoryBeanTest {
}
@Test
public void testDestroyWhenCacheIsNull() throws Exception {
public void destroyWhenCacheIsNull() throws Exception {
final AtomicBoolean fetchCacheCalled = new AtomicBoolean(false);
CacheFactoryBean cacheFactoryBean = new CacheFactoryBean() {
@Override protected GemFireCache fetchCache() {
@Override protected <T extends GemFireCache> T fetchCache() {
fetchCacheCalled.set(true);
return null;
}
@@ -425,14 +511,14 @@ public class CacheFactoryBeanTest {
}
@Test
public void testDestroyWhenClosedIsFalse() throws Exception {
public void destroyWhenClosedIsFalse() throws Exception {
final AtomicBoolean fetchCacheCalled = new AtomicBoolean(false);
final Cache mockCache = mock(Cache.class, "GemFireCache");
CacheFactoryBean cacheFactoryBean = new CacheFactoryBean() {
@Override protected GemFireCache fetchCache() {
@Override @SuppressWarnings("unchecked") protected <T extends GemFireCache> T fetchCache() {
fetchCacheCalled.set(true);
return mockCache;
return (T) mockCache;
}
};
@@ -447,7 +533,7 @@ public class CacheFactoryBeanTest {
}
@Test
public void testSetAndGetCacheFactoryBeanProperties() throws Exception {
public void setAndGetCacheFactoryBeanProperties() throws Exception {
BeanFactory mockBeanFactory = mock(BeanFactory.class, "SpringBeanFactory");
GatewayConflictResolver mockGatewayConflictResolver = mock(GatewayConflictResolver.class, "GemFireGatewayConflictResolver");
PdxSerializer mockPdxSerializer = mock(PdxSerializer.class, "GemFirePdxSerializer");

240
src/test/java/org/springframework/data/gemfire/client/ClientCacheFactoryBeanTest.java
View File

@@ -18,6 +18,8 @@ package org.springframework.data.gemfire.client;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
@@ -41,7 +43,9 @@ import com.gemstone.gemfire.cache.GemFireCache;
import com.gemstone.gemfire.cache.client.ClientCache;
import com.gemstone.gemfire.cache.client.ClientCacheFactory;
import com.gemstone.gemfire.cache.client.Pool;
import com.gemstone.gemfire.distributed.DistributedSystem;
import com.gemstone.gemfire.internal.lang.ClassUtils;
import com.gemstone.gemfire.pdx.PdxSerializer;
/**
* The ClientCacheFactoryBeanTest class is a test suite of test cases testing the contract and functionality
@@ -51,22 +55,198 @@ import com.gemstone.gemfire.internal.lang.ClassUtils;
* @see org.mockito.Mockito
* @see org.junit.Test
* @see org.springframework.data.gemfire.client.ClientCacheFactoryBean
* @see org.springframework.data.gemfire.TestUtils
* @since 1.7.0
*/
public class ClientCacheFactoryBeanTest {
protected Properties createProperties(String key, String value) {
Properties properties = new Properties();
properties.setProperty(key, value);
return properties;
}
@Test
public void testGetObjectType() {
public void getObjectType() {
assertEquals(ClientCache.class, new ClientCacheFactoryBean().getObjectType());
}
@Test
public void testIsSingleton() {
public void isSingleton() {
assertTrue(new ClientCacheFactoryBean().isSingleton());
}
@Test
public void testCreateCache() {
public void resolvePropertiesWhenDistributedSystemIsConnected() {
Properties gemfireProperties = createProperties("gf", "test");
Properties distributedSystemProperties = createProperties("ds", "mock");
final DistributedSystem mockDistributedSystem = mock(DistributedSystem.class, "MockGemFireDistributedSystem");
when(mockDistributedSystem.isConnected()).thenReturn(true);
when(mockDistributedSystem.getProperties()).thenReturn(distributedSystemProperties);
ClientCacheFactoryBean clientCacheFactoryBean = new ClientCacheFactoryBean() {
@SuppressWarnings("unchecked") @Override <T extends DistributedSystem> T getDistributedSystem() {
return (T) mockDistributedSystem;
}
};
clientCacheFactoryBean.setProperties(gemfireProperties);
Properties resolvedProperties = clientCacheFactoryBean.resolveProperties();
assertNotNull(resolvedProperties);
assertNotSame(gemfireProperties, resolvedProperties);
assertNotSame(distributedSystemProperties, resolvedProperties);
assertEquals(2, resolvedProperties.size());
assertEquals("test", resolvedProperties.getProperty("gf"));
assertEquals("mock", resolvedProperties.getProperty("ds"));
verify(mockDistributedSystem, times(1)).isConnected();
verify(mockDistributedSystem, times(1)).getProperties();
}
@Test
public void resolvePropertiesWhenDistributedSystemIsDisconnected() {
Properties gemfireProperties = createProperties("gf", "test");
Properties distributedSystemProperties = createProperties("ds", "mock");
final DistributedSystem mockDistributedSystem = mock(DistributedSystem.class, "MockGemFireDistributedSystem");
when(mockDistributedSystem.isConnected()).thenReturn(false);
when(mockDistributedSystem.getProperties()).thenReturn(distributedSystemProperties);
ClientCacheFactoryBean clientCacheFactoryBean = new ClientCacheFactoryBean() {
@SuppressWarnings("unchecked") @Override <T extends DistributedSystem> T getDistributedSystem() {
return (T) mockDistributedSystem;
}
};
clientCacheFactoryBean.setProperties(gemfireProperties);
Properties resolvedProperties = clientCacheFactoryBean.resolveProperties();
assertSame(gemfireProperties, resolvedProperties);
verify(mockDistributedSystem, times(1)).isConnected();
verify(mockDistributedSystem, never()).getProperties();
}
@Test
public void resolvePropertiesWhenDistributedSystemIsNull() {
Properties gemfireProperties = createProperties("gf", "test");
ClientCacheFactoryBean clientCacheFactoryBean = new ClientCacheFactoryBean() {
@Override <T extends DistributedSystem> T getDistributedSystem() {
return null;
}
};
clientCacheFactoryBean.setProperties(gemfireProperties);
Properties resolvedProperties = clientCacheFactoryBean.resolveProperties();
assertSame(gemfireProperties, resolvedProperties);
}
@Test
public void createClientCacheFactory() {
Properties gemfireProperties = new Properties();
Object clientCacheFactoryReference = new ClientCacheFactoryBean().createFactory(gemfireProperties);
assertTrue(gemfireProperties.isEmpty());
assertTrue(clientCacheFactoryReference instanceof ClientCacheFactory);
ClientCacheFactory clientCacheFactory = (ClientCacheFactory) clientCacheFactoryReference;
clientCacheFactory.set("name", "TestCreateClientCacheFactory");
assertTrue(gemfireProperties.containsKey("name"));
assertEquals("TestCreateClientCacheFactory", gemfireProperties.get("name"));
}
@Test
public void prepareClientCacheFactoryWithUnspecifiedPdxOptions() {
ClientCacheFactory mockClientCacheFactory = mock(ClientCacheFactory.class, "MockGemFireClientCacheFactory");
assertSame(mockClientCacheFactory, new ClientCacheFactoryBean().prepareFactory(mockClientCacheFactory));
verify(mockClientCacheFactory, never()).setPdxSerializer(any(PdxSerializer.class));
verify(mockClientCacheFactory, never()).setPdxDiskStore(any(String.class));
verify(mockClientCacheFactory, never()).setPdxIgnoreUnreadFields(any(Boolean.class));
verify(mockClientCacheFactory, never()).setPdxPersistent(any(Boolean.class));
verify(mockClientCacheFactory, never()).setPdxReadSerialized(any(Boolean.class));
}
@Test
public void prepareClientCacheFactoryWithPartialPdxOptions() {
ClientCacheFactoryBean clientCacheFactoryBean = new ClientCacheFactoryBean();
clientCacheFactoryBean.setPdxSerializer(mock(PdxSerializer.class));
clientCacheFactoryBean.setPdxReadSerialized(true);
clientCacheFactoryBean.setPdxIgnoreUnreadFields(false);
ClientCacheFactory mockClientCacheFactory = mock(ClientCacheFactory.class, "MockGemFireClientCacheFactory");
assertSame(mockClientCacheFactory, clientCacheFactoryBean.prepareFactory(mockClientCacheFactory));
verify(mockClientCacheFactory, times(1)).setPdxSerializer(any(PdxSerializer.class));
verify(mockClientCacheFactory, never()).setPdxDiskStore(any(String.class));
verify(mockClientCacheFactory, times(1)).setPdxIgnoreUnreadFields(eq(false));
verify(mockClientCacheFactory, never()).setPdxPersistent(any(Boolean.class));
verify(mockClientCacheFactory, times(1)).setPdxReadSerialized(eq(true));
}
@Test
public void prepareClientCacheFactoryWithAllPdxOptions() {
ClientCacheFactoryBean clientCacheFactoryBean = new ClientCacheFactoryBean();
clientCacheFactoryBean.setPdxSerializer(mock(PdxSerializer.class));
clientCacheFactoryBean.setPdxDiskStoreName("mockPdxDiskStoreName");
clientCacheFactoryBean.setPdxIgnoreUnreadFields(false);
clientCacheFactoryBean.setPdxPersistent(true);
clientCacheFactoryBean.setPdxReadSerialized(true);
ClientCacheFactory mockClientCacheFactory = mock(ClientCacheFactory.class, "MockGemFireClientCacheFactory");
assertSame(mockClientCacheFactory, clientCacheFactoryBean.prepareFactory(mockClientCacheFactory));
verify(mockClientCacheFactory, times(1)).setPdxSerializer(any(PdxSerializer.class));
verify(mockClientCacheFactory, times(1)).setPdxDiskStore(eq("mockPdxDiskStoreName"));
verify(mockClientCacheFactory, times(1)).setPdxIgnoreUnreadFields(eq(false));
verify(mockClientCacheFactory, times(1)).setPdxPersistent(eq(true));
verify(mockClientCacheFactory, times(1)).setPdxReadSerialized(eq(true));
}
@Test(expected = IllegalArgumentException.class)
public void prepareClientCacheFactoryWithInvalidTypeForPdxSerializer() {
ClientCacheFactory mockClientCacheFactory = mock(ClientCacheFactory.class, "MockGemFireClientCacheFactory");
try {
ClientCacheFactoryBean clientCacheFactoryBean = new ClientCacheFactoryBean();
clientCacheFactoryBean.setPdxSerializer(new Object());
clientCacheFactoryBean.setPdxReadSerialized(true);
clientCacheFactoryBean.setPdxIgnoreUnreadFields(true);
clientCacheFactoryBean.prepareFactory(mockClientCacheFactory);
}
catch (IllegalArgumentException expected) {
assertTrue(expected.getMessage().startsWith("Invalid pdx serializer used"));
assertNull(expected.getCause());
throw expected;
}
finally {
verify(mockClientCacheFactory, never()).setPdxSerializer(any(PdxSerializer.class));
verify(mockClientCacheFactory, never()).setPdxDiskStore(any(String.class));
verify(mockClientCacheFactory, never()).setPdxIgnoreUnreadFields(any(Boolean.class));
verify(mockClientCacheFactory, never()).setPdxPersistent(any(Boolean.class));
verify(mockClientCacheFactory, never()).setPdxReadSerialized(any(Boolean.class));
}
}
@Test
public void createCache() {
BeanFactory mockBeanFactory = mock(BeanFactory.class, "MockSpringBeanFactory");
ClientCacheFactory mockClientCacheFactory = mock(ClientCacheFactory.class, "MockGemFireClientCacheFactory");
ClientCache mockClientCache = mock(ClientCache.class, "MockGemFireClientCache");
@@ -129,23 +309,7 @@ public class ClientCacheFactoryBeanTest {
}
@Test
public void testCreateClientCacheFactory() {
Properties gemfireProperties = new Properties();
Object clientCacheFactoryReference = new ClientCacheFactoryBean().createFactory(gemfireProperties);
assertTrue(gemfireProperties.isEmpty());
assertTrue(clientCacheFactoryReference instanceof ClientCacheFactory);
ClientCacheFactory clientCacheFactory = (ClientCacheFactory) clientCacheFactoryReference;
clientCacheFactory.set("name", "TestCreateClientCacheFactory");
assertTrue(gemfireProperties.containsKey("name"));
assertEquals("TestCreateClientCacheFactory", gemfireProperties.get("name"));
}
@Test
public void testResolvePoolWithUnresolvablePoolName() throws Exception {
public void resolvePoolWithUnresolvablePoolName() throws Exception {
BeanFactory mockBeanFactory = mock(BeanFactory.class, "MockSpringBeanFactory");
ClientCacheFactory mockClientCacheFactory = mock(ClientCacheFactory.class, "MockGemFireClientCacheFactory");
ClientCache mockClientCache = mock(ClientCache.class, "MockGemFireClientCache");
@@ -213,7 +377,7 @@ public class ClientCacheFactoryBeanTest {
}
@Test(expected = BeanInitializationException.class)
public void testResolveUnresolvablePool() {
public void resolveUnresolvablePool() {
ClientCacheFactory mockClientCacheFactory = mock(ClientCacheFactory.class, "MockGemFireClientCacheFactory");
try {
@@ -246,12 +410,31 @@ public class ClientCacheFactoryBeanTest {
}
@Test
public void testAutoReconnectDisabled() {
public void postProcessClientCacheAndSignalReadyForEvents() throws Exception {
ClientCache mockClientCache = mock(ClientCache.class, "MockGemFireClientCache");
ClientCacheFactoryBean clientCacheFactoryBean = new ClientCacheFactoryBean();
clientCacheFactoryBean.setReadyForEvents(true);
assertTrue(clientCacheFactoryBean.getReadyForEvents());
assertSame(mockClientCache, clientCacheFactoryBean.postProcess(mockClientCache));
verify(mockClientCache, times(1)).readyForEvents();
}
@Test
public void autoReconnectDisabled() {
assertFalse(new ClientCacheFactoryBean().getEnableAutoReconnect());
}
@Test(expected = UnsupportedOperationException.class)
public void enableAutoReconnect() {
new ClientCacheFactoryBean().setEnableAutoReconnect(true);
}
@Test(expected = IllegalArgumentException.class)
public void testSetPoolToNull() {
public void setPoolToNull() {
try {
new ClientCacheFactoryBean().setPool(null);
}
@@ -262,7 +445,7 @@ public class ClientCacheFactoryBeanTest {
}
@Test(expected = IllegalArgumentException.class)
public void testSetPoolNameToInvalidValue() {
public void setPoolNameToInvalidValue() {
try {
new ClientCacheFactoryBean().setPoolName(" ");
}
@@ -273,7 +456,7 @@ public class ClientCacheFactoryBeanTest {
}
@Test
public void testSetAndGetReadyForEvents() {
public void setAndGetReadyForEvents() {
ClientCacheFactoryBean clientCacheFactoryBean = new ClientCacheFactoryBean();
assertFalse(clientCacheFactoryBean.getReadyForEvents());
@@ -288,8 +471,13 @@ public class ClientCacheFactoryBeanTest {
}
@Test
public void testUsesClusterConfiguration() {
public void clusterConfigurationNotUsed() {
assertFalse(new ClientCacheFactoryBean().getUseClusterConfiguration());
}
@Test(expected = UnsupportedOperationException.class)
public void useClusterConfiguration() {
new ClientCacheFactoryBean().setUseClusterConfiguration(true);
}
}