From 130cc4ca4c84a0151ba8f98194a3522ac7e34121 Mon Sep 17 00:00:00 2001 From: John Blum Date: Fri, 10 Jul 2015 16:56:29 -0700 Subject: [PATCH] SGF-414 - Resolve incompatibility between the DistributedSystem created by the PoolFactoryBean and the DistributedSystem resolved by the ClientCacheFactoryBean when SSL is configured. Added additional test cases for the CacheFactoryBean and ClientCacheFactoryBean based on SSL support. 1.7 SDG XSD cleanup. --- .../data/gemfire/CacheFactoryBean.java | 4 +- .../gemfire/config/spring-gemfire-1.7.xsd | 6 +- .../data/gemfire/CacheFactoryBeanTest.java | 291 ++++++++++++------ .../client/ClientCacheFactoryBeanTest.java | 240 +++++++++++++-- 4 files changed, 407 insertions(+), 134 deletions(-) diff --git a/src/main/java/org/springframework/data/gemfire/CacheFactoryBean.java b/src/main/java/org/springframework/data/gemfire/CacheFactoryBean.java index b9d18f60..4e65fe3f 100644 --- a/src/main/java/org/springframework/data/gemfire/CacheFactoryBean.java +++ b/src/main/java/org/springframework/data/gemfire/CacheFactoryBean.java @@ -494,7 +494,7 @@ public class CacheFactoryBean implements BeanClassLoaderAware, BeanFactoryAware, @Override public void destroy() throws Exception { if (close) { - Cache localCache = (Cache) fetchCache(); + Cache localCache = fetchCache(); if (localCache != null && !localCache.isClosed()) { localCache.close(); @@ -510,7 +510,7 @@ public class CacheFactoryBean implements BeanClassLoaderAware, BeanFactoryAware, } @Override - public DataAccessException translateExceptionIfPossible(final RuntimeException e) { + public DataAccessException translateExceptionIfPossible(RuntimeException e) { if (e instanceof GemFireException) { return GemfireCacheUtils.convertGemfireAccessException((GemFireException) e); } diff --git a/src/main/resources/org/springframework/data/gemfire/config/spring-gemfire-1.7.xsd b/src/main/resources/org/springframework/data/gemfire/config/spring-gemfire-1.7.xsd index 6a42798a..1aaf4cb5 100644 --- a/src/main/resources/org/springframework/data/gemfire/config/spring-gemfire-1.7.xsd +++ b/src/main/resources/org/springframework/data/gemfire/config/spring-gemfire-1.7.xsd @@ -349,16 +349,14 @@ Defines a GemFire Client Cache instance used for creating or retrieving 'regions - + - + 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"); diff --git a/src/test/java/org/springframework/data/gemfire/client/ClientCacheFactoryBeanTest.java b/src/test/java/org/springframework/data/gemfire/client/ClientCacheFactoryBeanTest.java index 7e052cdf..e954aa0b 100644 --- a/src/test/java/org/springframework/data/gemfire/client/ClientCacheFactoryBeanTest.java +++ b/src/test/java/org/springframework/data/gemfire/client/ClientCacheFactoryBeanTest.java @@ -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 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 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 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); + } + }