From 06d1df02ceab4765878291525861d24951a30197 Mon Sep 17 00:00:00 2001 From: John Blum Date: Tue, 31 Mar 2015 16:52:00 -0700 Subject: [PATCH] SGF-389 - Improve unit test coverage of the ClientCacheFactoryBean class. --- .../data/gemfire/CacheFactoryBean.java | 29 +- .../client/ClientCacheFactoryBean.java | 81 +++-- .../data/gemfire/CacheFactoryBeanTest.java | 35 +++ .../client/ClientCacheFactoryBeanTest.java | 295 ++++++++++++++++++ 4 files changed, 396 insertions(+), 44 deletions(-) create mode 100644 src/test/java/org/springframework/data/gemfire/client/ClientCacheFactoryBeanTest.java diff --git a/src/main/java/org/springframework/data/gemfire/CacheFactoryBean.java b/src/main/java/org/springframework/data/gemfire/CacheFactoryBean.java index 3454ad61..2018c59e 100644 --- a/src/main/java/org/springframework/data/gemfire/CacheFactoryBean.java +++ b/src/main/java/org/springframework/data/gemfire/CacheFactoryBean.java @@ -263,12 +263,7 @@ public class CacheFactoryBean implements BeanClassLoaderAware, BeanFactoryAware, /* (non-Javadoc) */ private Cache init() throws Exception { - if (useBeanFactoryLocator && beanFactoryLocator == null) { - beanFactoryLocator = new GemfireBeanFactoryLocator(); - beanFactoryLocator.setBeanFactory(beanFactory); - beanFactoryLocator.setBeanName(beanName); - beanFactoryLocator.afterPropertiesSet(); - } + initBeanFactoryLocator(); final ClassLoader currentThreadContextClassLoader = Thread.currentThread().getContextClassLoader(); @@ -297,10 +292,20 @@ public class CacheFactoryBean implements BeanClassLoaderAware, BeanFactoryAware, } } + /* (non-Javadoc) */ + private void initBeanFactoryLocator() { + if (useBeanFactoryLocator && beanFactoryLocator == null) { + beanFactoryLocator = new GemfireBeanFactoryLocator(); + beanFactoryLocator.setBeanFactory(beanFactory); + beanFactoryLocator.setBeanName(beanName); + beanFactoryLocator.afterPropertiesSet(); + } + } + /** * If Dynamic Regions are enabled, create and initialize a DynamicRegionFactory before creating the Cache. */ - private void initializeDynamicRegionFactory() { + private void initDynamicRegionFactory() { if (dynamicRegionSupport != null) { dynamicRegionSupport.initializeDynamicRegionFactory(); } @@ -314,7 +319,7 @@ public class CacheFactoryBean implements BeanClassLoaderAware, BeanFactoryAware, * @see com.gemstone.gemfire.cache.Cache * @see #fetchCache() * @see #createFactory(java.util.Properties) - * @see #initializeFactory(Object) + * @see #prepareFactory(Object) * @see #createCache(Object) */ protected Cache resolveCache() { @@ -324,8 +329,8 @@ public class CacheFactoryBean implements BeanClassLoaderAware, BeanFactoryAware, } catch (CacheClosedException ex) { cacheResolutionMessagePrefix = "Created new"; - initializeDynamicRegionFactory(); - return (Cache) createCache(initializeFactory(createFactory(getProperties()))); + initDynamicRegionFactory(); + return (Cache) createCache(prepareFactory(createFactory(getProperties()))); } } @@ -373,7 +378,7 @@ public class CacheFactoryBean implements BeanClassLoaderAware, BeanFactoryAware, * @return the initialized GemFire factory. * @see #setPdxOptions(Object) */ - protected Object initializeFactory(Object factory) { + protected Object prepareFactory(Object factory) { if (isPdxOptionsSpecified()) { Assert.isTrue(ClassUtils.isPresent("com.gemstone.gemfire.pdx.PdxSerializer", beanClassLoader), "Unable set PDX options since GemFire 6.6 or later was not detected."); @@ -871,7 +876,7 @@ public class CacheFactoryBean implements BeanClassLoaderAware, BeanFactoryAware, } @Override - public Class getObjectType() { + public Class getObjectType() { return (cache != null ? cache.getClass() : Cache.class); } diff --git a/src/main/java/org/springframework/data/gemfire/client/ClientCacheFactoryBean.java b/src/main/java/org/springframework/data/gemfire/client/ClientCacheFactoryBean.java index 90ac33c1..259717f7 100644 --- a/src/main/java/org/springframework/data/gemfire/client/ClientCacheFactoryBean.java +++ b/src/main/java/org/springframework/data/gemfire/client/ClientCacheFactoryBean.java @@ -16,6 +16,7 @@ package org.springframework.data.gemfire.client; +import java.io.IOException; import java.net.InetSocketAddress; import java.util.Properties; @@ -25,6 +26,7 @@ import org.springframework.data.gemfire.config.GemfireConstants; import org.springframework.util.Assert; import org.springframework.util.StringUtils; +import com.gemstone.gemfire.cache.Cache; import com.gemstone.gemfire.cache.GemFireCache; import com.gemstone.gemfire.cache.client.ClientCache; import com.gemstone.gemfire.cache.client.ClientCacheFactory; @@ -88,18 +90,14 @@ public class ClientCacheFactoryBean extends CacheFactoryBean { protected void postProcessPropertiesBeforeInitialization(Properties gemfireProperties) { } + @Override + protected GemFireCache fetchCache() { + return ClientCacheFactory.getAnyInstance(); + } + @Override protected GemFireCache createCache(Object factory) { - ClientCacheFactory clientCacheFactory = (ClientCacheFactory) factory; - - initializePool(clientCacheFactory); - - GemFireCache cache = clientCacheFactory.create(); - - // register for events after Pool and Regions been created and iff non-durable client... - readyForEvents(); - - return cache; + return initializePool((ClientCacheFactory) factory).create(); } @Override @@ -107,19 +105,14 @@ public class ClientCacheFactoryBean extends CacheFactoryBean { return new ClientCacheFactory(gemfireProperties); } - @Override - protected GemFireCache fetchCache() { - return ClientCacheFactory.getAnyInstance(); - } - /** * Initialize the Pool settings on the ClientCacheFactory. * * @param clientCacheFactory the GemFire ClientCacheFactory used to configure and create a GemFire ClientCache. * @see com.gemstone.gemfire.cache.client.ClientCacheFactory */ - private void initializePool(ClientCacheFactory clientCacheFactory) { - initializeClientCacheFactoryPoolSettings(clientCacheFactory, resolvePool(this.pool)); + private ClientCacheFactory initializePool(ClientCacheFactory clientCacheFactory) { + return initializeClientCacheFactoryPool(clientCacheFactory, resolvePool(this.pool)); } /** @@ -148,9 +141,9 @@ public class ClientCacheFactoryBean extends CacheFactoryBean { } catch (Exception e) { throw new BeanInitializationException(String.format( - "No bean of type '%1$s' having name '%2$s' was found.%3$s", Pool.class.getName(), poolName, - (GemfireConstants.DEFAULT_GEMFIRE_POOL_NAME.equals(poolName) - ? " A client cache requires a pool." : "")), e); + "no Bean of type '%1$s' having name '%2$s' was found%3$s", Pool.class.getName(), poolName, + (GemfireConstants.DEFAULT_GEMFIRE_POOL_NAME.equals(poolName) + ? "; a ClientCache requires a Pool" : "")), e); } } } @@ -166,7 +159,7 @@ public class ClientCacheFactoryBean extends CacheFactoryBean { * @see com.gemstone.gemfire.cache.client.ClientCacheFactory * @see com.gemstone.gemfire.cache.client.Pool */ - private void initializeClientCacheFactoryPoolSettings(ClientCacheFactory clientCacheFactory, Pool pool) { + private ClientCacheFactory initializeClientCacheFactoryPool(ClientCacheFactory clientCacheFactory, Pool pool) { if (pool != null) { clientCacheFactory.setPoolFreeConnectionTimeout(pool.getFreeConnectionTimeout()); clientCacheFactory.setPoolIdleTimeout(pool.getIdleTimeout()); @@ -195,6 +188,8 @@ public class ClientCacheFactoryBean extends CacheFactoryBean { clientCacheFactory.addPoolServer(socketAddress.getHostName(), socketAddress.getPort()); } } + + return clientCacheFactory; } @Override @@ -210,7 +205,7 @@ public class ClientCacheFactoryBean extends CacheFactoryBean { private void readyForEvents(){ ClientCache clientCache = ClientCacheFactory.getAnyInstance(); - if (Boolean.TRUE.equals(readyForEvents) && !clientCache.isClosed()) { + if (Boolean.TRUE.equals(getReadyForEvents()) && !clientCache.isClosed()) { try { clientCache.readyForEvents(); } @@ -220,14 +215,36 @@ public class ClientCacheFactoryBean extends CacheFactoryBean { } } + /** + * Register for events after Pool and Regions have been created and iff non-durable client... + * + * @param cache the GemFire Cache instance to process. + * @return the processed GemFire Cache instance after ready for events. + * @throws IOException if an error occurs during post processing. + * @see org.springframework.data.gemfire.CacheFactoryBean#postProcess(com.gemstone.gemfire.cache.Cache) + * @see #readyForEvents() + * @see com.gemstone.gemfire.cache.Cache + */ + @Override + protected Cache postProcess(final Cache cache) throws IOException { + Cache localCache = super.postProcess(cache); + readyForEvents(); + return localCache; + } + + @Override + public final void setEnableAutoReconnect(final Boolean enableAutoReconnect) { + throw new UnsupportedOperationException("Auto-reconnect is not supported on ClientCache."); + } + @Override public final Boolean getEnableAutoReconnect() { return Boolean.FALSE; } @Override - public final void setEnableAutoReconnect(final Boolean enableAutoReconnect) { - throw new UnsupportedOperationException("Auto-reconnect is not supported on ClientCache."); + public Class getObjectType() { + return (cache != null ? cache.getClass() : ClientCache.class); } /** @@ -236,7 +253,7 @@ public class ClientCacheFactoryBean extends CacheFactoryBean { * @param pool the GemFire pool used by the Client Cache to obtain connections to the GemFire cluster. */ public void setPool(Pool pool) { - Assert.notNull(pool, "The GemFire Pool must not be null!"); + Assert.notNull(pool, "GemFire Pool must not be null"); this.pool = pool; } @@ -246,7 +263,7 @@ public class ClientCacheFactoryBean extends CacheFactoryBean { * @param poolName set the name of the GemFire Pool used by the GemFire Client Cache. */ public void setPoolName(String poolName) { - Assert.hasText(poolName, "The Pool 'name' is required!"); + Assert.hasText(poolName, "Pool 'name' is required"); this.poolName = poolName; } @@ -267,12 +284,7 @@ public class ClientCacheFactoryBean extends CacheFactoryBean { * @return a boolean value indicating the state of the 'readyForEvents' property. */ public Boolean getReadyForEvents(){ - return this.readyForEvents; - } - - @Override - public final Boolean getUseClusterConfiguration() { - return Boolean.FALSE; + return readyForEvents; } @Override @@ -280,4 +292,9 @@ public class ClientCacheFactoryBean extends CacheFactoryBean { throw new UnsupportedOperationException("Shared, cluster configuration is not applicable to clients."); } + @Override + public final Boolean getUseClusterConfiguration() { + return Boolean.FALSE; + } + } diff --git a/src/test/java/org/springframework/data/gemfire/CacheFactoryBeanTest.java b/src/test/java/org/springframework/data/gemfire/CacheFactoryBeanTest.java index 01fe04ba..f68a2249 100644 --- a/src/test/java/org/springframework/data/gemfire/CacheFactoryBeanTest.java +++ b/src/test/java/org/springframework/data/gemfire/CacheFactoryBeanTest.java @@ -204,6 +204,41 @@ public class CacheFactoryBeanTest { 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 { diff --git a/src/test/java/org/springframework/data/gemfire/client/ClientCacheFactoryBeanTest.java b/src/test/java/org/springframework/data/gemfire/client/ClientCacheFactoryBeanTest.java new file mode 100644 index 00000000..7e052cdf --- /dev/null +++ b/src/test/java/org/springframework/data/gemfire/client/ClientCacheFactoryBeanTest.java @@ -0,0 +1,295 @@ +/* + * Copyright 2010-2013 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.springframework.data.gemfire.client; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertSame; +import static org.junit.Assert.assertTrue; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import java.util.Properties; + +import org.junit.Test; +import org.springframework.beans.factory.BeanFactory; +import org.springframework.beans.factory.BeanInitializationException; +import org.springframework.data.gemfire.TestUtils; +import org.springframework.data.gemfire.config.GemfireConstants; + +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.internal.lang.ClassUtils; + +/** + * The ClientCacheFactoryBeanTest class is a test suite of test cases testing the contract and functionality + * of the SDG ClientCacheFactoryBean class. + * + * @author John Blum + * @see org.mockito.Mockito + * @see org.junit.Test + * @see org.springframework.data.gemfire.client.ClientCacheFactoryBean + * @since 1.7.0 + */ +public class ClientCacheFactoryBeanTest { + + @Test + public void testGetObjectType() { + assertEquals(ClientCache.class, new ClientCacheFactoryBean().getObjectType()); + } + + @Test + public void testIsSingleton() { + assertTrue(new ClientCacheFactoryBean().isSingleton()); + } + + @Test + public void testCreateCache() { + BeanFactory mockBeanFactory = mock(BeanFactory.class, "MockSpringBeanFactory"); + ClientCacheFactory mockClientCacheFactory = mock(ClientCacheFactory.class, "MockGemFireClientCacheFactory"); + ClientCache mockClientCache = mock(ClientCache.class, "MockGemFireClientCache"); + Pool mockPool = mock(Pool.class, "MockGemFirePool"); + + when(mockClientCacheFactory.create()).thenReturn(mockClientCache); + when(mockBeanFactory.isTypeMatch(eq("testCreateCache.Pool"), eq(Pool.class))).thenReturn(true); + when(mockBeanFactory.getBean(eq("testCreateCache.Pool"), eq(Pool.class))).thenReturn(mockPool); + when(mockPool.getFreeConnectionTimeout()).thenReturn(30000); + when(mockPool.getIdleTimeout()).thenReturn(60000l); + when(mockPool.getLoadConditioningInterval()).thenReturn(45000); + when(mockPool.getMaxConnections()).thenReturn(100); + when(mockPool.getMinConnections()).thenReturn(10); + when(mockPool.getMultiuserAuthentication()).thenReturn(true); + when(mockPool.getPingInterval()).thenReturn(15000l); + when(mockPool.getPRSingleHopEnabled()).thenReturn(true); + when(mockPool.getReadTimeout()).thenReturn(20000); + when(mockPool.getRetryAttempts()).thenReturn(10); + when(mockPool.getServerGroup()).thenReturn("TestServerGroup"); + when(mockPool.getSocketBufferSize()).thenReturn(32768); + when(mockPool.getStatisticInterval()).thenReturn(5000); + when(mockPool.getSubscriptionAckInterval()).thenReturn(15000); + when(mockPool.getSubscriptionEnabled()).thenReturn(true); + when(mockPool.getSubscriptionMessageTrackingTimeout()).thenReturn(30000); + when(mockPool.getSubscriptionRedundancy()).thenReturn(2); + when(mockPool.getThreadLocalConnections()).thenReturn(false); + + ClientCacheFactoryBean clientCacheFactoryBean = new ClientCacheFactoryBean(); + + clientCacheFactoryBean.setBeanFactory(mockBeanFactory); + clientCacheFactoryBean.setPoolName("testCreateCache.Pool"); + clientCacheFactoryBean.setReadyForEvents(false); + + GemFireCache actualCache = clientCacheFactoryBean.createCache(mockClientCacheFactory); + + assertSame(mockClientCache, actualCache); + + verify(mockClientCacheFactory, times(1)).create(); + verify(mockBeanFactory, times(1)).isTypeMatch(eq("testCreateCache.Pool"), eq(Pool.class)); + verify(mockBeanFactory, times(1)).getBean(eq("testCreateCache.Pool"), eq(Pool.class)); + verify(mockBeanFactory, never()).getBean(eq(Pool.class)); + verify(mockClientCacheFactory, times(1)).setPoolFreeConnectionTimeout(eq(30000)); + verify(mockClientCacheFactory, times(1)).setPoolIdleTimeout(eq(60000l)); + verify(mockClientCacheFactory, times(1)).setPoolLoadConditioningInterval(eq(45000)); + verify(mockClientCacheFactory, times(1)).setPoolMaxConnections(eq(100)); + verify(mockClientCacheFactory, times(1)).setPoolMinConnections(eq(10)); + verify(mockClientCacheFactory, times(1)).setPoolMultiuserAuthentication(eq(true)); + verify(mockClientCacheFactory, times(1)).setPoolPingInterval(eq(15000l)); + verify(mockClientCacheFactory, times(1)).setPoolPRSingleHopEnabled(eq(true)); + verify(mockClientCacheFactory, times(1)).setPoolReadTimeout(eq(20000)); + verify(mockClientCacheFactory, times(1)).setPoolRetryAttempts(eq(10)); + verify(mockClientCacheFactory, times(1)).setPoolServerGroup(eq("TestServerGroup")); + verify(mockClientCacheFactory, times(1)).setPoolSocketBufferSize(eq(32768)); + verify(mockClientCacheFactory, times(1)).setPoolStatisticInterval(eq(5000)); + verify(mockClientCacheFactory, times(1)).setPoolSubscriptionAckInterval(eq(15000)); + verify(mockClientCacheFactory, times(1)).setPoolSubscriptionEnabled(eq(true)); + verify(mockClientCacheFactory, times(1)).setPoolSubscriptionMessageTrackingTimeout(eq(30000)); + verify(mockClientCacheFactory, times(1)).setPoolSubscriptionRedundancy(eq(2)); + verify(mockClientCacheFactory, times(1)).setPoolThreadLocalConnections(eq(false)); + } + + @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 { + BeanFactory mockBeanFactory = mock(BeanFactory.class, "MockSpringBeanFactory"); + ClientCacheFactory mockClientCacheFactory = mock(ClientCacheFactory.class, "MockGemFireClientCacheFactory"); + ClientCache mockClientCache = mock(ClientCache.class, "MockGemFireClientCache"); + Pool mockPool = mock(Pool.class, "MockGemFirePool"); + + when(mockBeanFactory.isTypeMatch(any(String.class), eq(Pool.class))).thenReturn(false); + when(mockBeanFactory.getBean(eq(Pool.class))).thenReturn(mockPool); + when(mockClientCacheFactory.create()).thenReturn(mockClientCache); + when(mockPool.getFreeConnectionTimeout()).thenReturn(120000); + when(mockPool.getIdleTimeout()).thenReturn(300000l); + when(mockPool.getLoadConditioningInterval()).thenReturn(15000); + when(mockPool.getMaxConnections()).thenReturn(50); + when(mockPool.getMinConnections()).thenReturn(5); + when(mockPool.getMultiuserAuthentication()).thenReturn(false); + when(mockPool.getName()).thenReturn("MockGemFirePool"); + when(mockPool.getPingInterval()).thenReturn(12000l); + when(mockPool.getPRSingleHopEnabled()).thenReturn(true); + when(mockPool.getReadTimeout()).thenReturn(60000); + when(mockPool.getRetryAttempts()).thenReturn(5); + when(mockPool.getServerGroup()).thenReturn("MockServerGroup"); + when(mockPool.getSocketBufferSize()).thenReturn(16384); + when(mockPool.getStatisticInterval()).thenReturn(1000); + when(mockPool.getSubscriptionAckInterval()).thenReturn(500); + when(mockPool.getSubscriptionEnabled()).thenReturn(true); + when(mockPool.getSubscriptionMessageTrackingTimeout()).thenReturn(15000); + when(mockPool.getSubscriptionRedundancy()).thenReturn(4); + when(mockPool.getThreadLocalConnections()).thenReturn(false); + + ClientCacheFactoryBean clientCacheFactoryBean = new ClientCacheFactoryBean(); + + clientCacheFactoryBean.setBeanFactory(mockBeanFactory); + clientCacheFactoryBean.setPoolName("TestGemFirePool"); + clientCacheFactoryBean.setReadyForEvents(false); + + assertEquals("TestGemFirePool", TestUtils.readField("poolName", clientCacheFactoryBean)); + + GemFireCache actualClientCache = clientCacheFactoryBean.createCache(mockClientCacheFactory); + + assertSame(mockClientCache, actualClientCache); + assertEquals("MockGemFirePool", TestUtils.readField("poolName", clientCacheFactoryBean)); + + verify(mockClientCacheFactory, times(1)).create(); + verify(mockBeanFactory, times(1)).isTypeMatch(eq("TestGemFirePool"), eq(Pool.class)); + verify(mockBeanFactory, never()).getBean(eq("TestGemFirePool"), eq(Pool.class)); + verify(mockBeanFactory, times(1)).getBean(eq(Pool.class)); + verify(mockPool, times(1)).getName(); + verify(mockClientCacheFactory, times(1)).setPoolFreeConnectionTimeout(eq(120000)); + verify(mockClientCacheFactory, times(1)).setPoolIdleTimeout(eq(300000l)); + verify(mockClientCacheFactory, times(1)).setPoolLoadConditioningInterval(eq(15000)); + verify(mockClientCacheFactory, times(1)).setPoolMaxConnections(eq(50)); + verify(mockClientCacheFactory, times(1)).setPoolMinConnections(eq(5)); + verify(mockClientCacheFactory, times(1)).setPoolMultiuserAuthentication(eq(false)); + verify(mockClientCacheFactory, times(1)).setPoolPingInterval(eq(12000l)); + verify(mockClientCacheFactory, times(1)).setPoolPRSingleHopEnabled(eq(true)); + verify(mockClientCacheFactory, times(1)).setPoolReadTimeout(eq(60000)); + verify(mockClientCacheFactory, times(1)).setPoolRetryAttempts(eq(5)); + verify(mockClientCacheFactory, times(1)).setPoolServerGroup(eq("MockServerGroup")); + verify(mockClientCacheFactory, times(1)).setPoolSocketBufferSize(eq(16384)); + verify(mockClientCacheFactory, times(1)).setPoolStatisticInterval(eq(1000)); + verify(mockClientCacheFactory, times(1)).setPoolSubscriptionAckInterval(eq(500)); + verify(mockClientCacheFactory, times(1)).setPoolSubscriptionEnabled(eq(true)); + verify(mockClientCacheFactory, times(1)).setPoolSubscriptionMessageTrackingTimeout(eq(15000)); + verify(mockClientCacheFactory, times(1)).setPoolSubscriptionRedundancy(eq(4)); + verify(mockClientCacheFactory, times(1)).setPoolThreadLocalConnections(eq(false)); + } + + @Test(expected = BeanInitializationException.class) + public void testResolveUnresolvablePool() { + ClientCacheFactory mockClientCacheFactory = mock(ClientCacheFactory.class, "MockGemFireClientCacheFactory"); + + try { + BeanFactory mockBeanFactory = mock(BeanFactory.class, "MockSpringBeanFactory"); + + when(mockBeanFactory.isTypeMatch(eq(GemfireConstants.DEFAULT_GEMFIRE_POOL_NAME), eq(Pool.class))) + .thenReturn(true); + when(mockBeanFactory.getBean(eq(GemfireConstants.DEFAULT_GEMFIRE_POOL_NAME), eq(Pool.class))) + .thenThrow(new IllegalArgumentException("TEST")); + + ClientCacheFactoryBean clientCacheFactoryBean = new ClientCacheFactoryBean(); + + clientCacheFactoryBean.setBeanFactory(mockBeanFactory); + clientCacheFactoryBean.setPoolName(GemfireConstants.DEFAULT_GEMFIRE_POOL_NAME); + clientCacheFactoryBean.setReadyForEvents(false); + clientCacheFactoryBean.createCache(mockClientCacheFactory); + } + catch (BeanInitializationException expected) { + assertTrue(expected.getMessage(), expected.getMessage().startsWith(String.format( + "no Bean of type '%1$s' having name '%2$s' was found; a ClientCache requires a Pool", + Pool.class.getName(), GemfireConstants.DEFAULT_GEMFIRE_POOL_NAME))); + assertTrue(String.format("Cause was: %1$s!", ClassUtils.getClassName(expected.getCause())), + expected.getCause() instanceof IllegalArgumentException); + assertEquals("TEST", expected.getCause().getMessage()); + throw expected; + } + finally { + verify(mockClientCacheFactory, never()).create(); + } + } + + @Test + public void testAutoReconnectDisabled() { + assertFalse(new ClientCacheFactoryBean().getEnableAutoReconnect()); + } + + @Test(expected = IllegalArgumentException.class) + public void testSetPoolToNull() { + try { + new ClientCacheFactoryBean().setPool(null); + } + catch (IllegalArgumentException expected) { + assertEquals("GemFire Pool must not be null", expected.getMessage()); + throw expected; + } + } + + @Test(expected = IllegalArgumentException.class) + public void testSetPoolNameToInvalidValue() { + try { + new ClientCacheFactoryBean().setPoolName(" "); + } + catch (IllegalArgumentException expected) { + assertEquals("Pool 'name' is required", expected.getMessage()); + throw expected; + } + } + + @Test + public void testSetAndGetReadyForEvents() { + ClientCacheFactoryBean clientCacheFactoryBean = new ClientCacheFactoryBean(); + + assertFalse(clientCacheFactoryBean.getReadyForEvents()); + + clientCacheFactoryBean.setReadyForEvents(true); + + assertTrue(clientCacheFactoryBean.getReadyForEvents()); + + clientCacheFactoryBean.setReadyForEvents(null); + + assertNull(clientCacheFactoryBean.getReadyForEvents()); + } + + @Test + public void testUsesClusterConfiguration() { + assertFalse(new ClientCacheFactoryBean().getUseClusterConfiguration()); + } + +}