diff --git a/src/main/java/org/springframework/data/gemfire/CacheFactoryBean.java b/src/main/java/org/springframework/data/gemfire/CacheFactoryBean.java index 86d9cfa6..e7af7758 100644 --- a/src/main/java/org/springframework/data/gemfire/CacheFactoryBean.java +++ b/src/main/java/org/springframework/data/gemfire/CacheFactoryBean.java @@ -508,7 +508,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 3b61b3b2..7664871f 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() { 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 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 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 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 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"); 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); + } + }