Spring/spring-data-gemfire
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 
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 4f2eb22163
commit 130cc4ca4c
4 changed files with 407 additions and 134 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -71,7 +71,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 +178,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() {
assumeTrue(GemfireUtils.isGemfireVersion8OrAbove());
Properties gemfireProperties = new Properties();
@@ -288,7 +197,7 @@ public class CacheFactoryBeanTest {
}
@Test
public void testPostProcessPropertiesBeforeInitializationDisabled() {
public void postProcessPropertiesBeforeInitializationDisabled() {
assumeTrue(GemfireUtils.isGemfireVersion8OrAbove());
Properties gemfireProperties = new Properties();
@@ -309,7 +218,7 @@ public class CacheFactoryBeanTest {
}
@Test
public void testPostProcessPropertiesBeforeInitializationEnabled() {
public void postProcessPropertiesBeforeInitializationEnabled() {
assumeTrue(GemfireUtils.isGemfireVersion8OrAbove());
Properties gemfireProperties = new Properties();
@@ -330,7 +239,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");
@@ -377,17 +464,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);
@@ -413,7 +500,7 @@ public class CacheFactoryBeanTest {
}
@Test
public void testDestroyWhenCacheIsNull() throws Exception {
public void destroyWhenCacheIsNull() throws Exception {
final AtomicBoolean fetchCacheCalled = new AtomicBoolean(false);
CacheFactoryBean cacheFactoryBean = new CacheFactoryBean() {
@@ -431,7 +518,7 @@ 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");
@@ -453,7 +540,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);
}
}