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

SGF-389 - Improve unit test coverage of the ClientCacheFactoryBean class.

Browse Source
This commit is contained in:
John Blum
2015-03-31 16:52:00 -07:00
parent 6c5887627a
commit 06d1df02ce
4 changed files with 396 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
src/main/java/org/springframework/data/gemfire/CacheFactoryBean.java
View File

@@ -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<? extends Cache> getObjectType() {
public Class<? extends GemFireCache> getObjectType() {
return (cache != null ? cache.getClass() : Cache.class);
}

81
src/main/java/org/springframework/data/gemfire/client/ClientCacheFactoryBean.java
View File

@@ -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<? extends GemFireCache> 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;
}
}

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

@@ -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 {

295
src/test/java/org/springframework/data/gemfire/client/ClientCacheFactoryBeanTest.java Normal file
View File

@@ -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());
}
}