diff --git a/src/main/java/org/springframework/data/gemfire/CacheFactoryBean.java b/src/main/java/org/springframework/data/gemfire/CacheFactoryBean.java index a1eb459f..6e735366 100644 --- a/src/main/java/org/springframework/data/gemfire/CacheFactoryBean.java +++ b/src/main/java/org/springframework/data/gemfire/CacheFactoryBean.java @@ -38,6 +38,8 @@ import org.springframework.core.io.Resource; import org.springframework.dao.DataAccessException; import org.springframework.dao.support.PersistenceExceptionTranslator; import org.springframework.data.gemfire.client.InterestResultPolicyConverter; +import org.springframework.data.gemfire.server.SubscriptionEvictionPolicy; +import org.springframework.data.gemfire.server.SubscriptionEvictionPolicyConverter; import org.springframework.util.Assert; import org.springframework.util.ClassUtils; import org.springframework.util.CollectionUtils; @@ -927,6 +929,7 @@ public class CacheFactoryBean implements BeanClassLoaderAware, BeanFactoryAware, beanFactory.registerCustomEditor(IndexType.class, IndexTypeConverter.class); beanFactory.registerCustomEditor(InterestPolicy.class, InterestPolicyConverter.class); beanFactory.registerCustomEditor(InterestResultPolicy.class, InterestResultPolicyConverter.class); + beanFactory.registerCustomEditor(SubscriptionEvictionPolicy.class, SubscriptionEvictionPolicyConverter.class); } } diff --git a/src/main/java/org/springframework/data/gemfire/config/CacheServerParser.java b/src/main/java/org/springframework/data/gemfire/config/CacheServerParser.java index 4103d313..9db99524 100644 --- a/src/main/java/org/springframework/data/gemfire/config/CacheServerParser.java +++ b/src/main/java/org/springframework/data/gemfire/config/CacheServerParser.java @@ -32,6 +32,11 @@ import org.w3c.dom.Element; * * @author Costin Leau * @author John Blum + * @see org.springframework.beans.factory.support.AbstractBeanDefinition + * @see org.springframework.beans.factory.support.BeanDefinitionBuilder + * @see org.springframework.beans.factory.xml.AbstractSimpleBeanDefinitionParser + * @see org.springframework.data.gemfire.server.CacheServerFactoryBean + * @since 1.1.0 */ class CacheServerParser extends AbstractSimpleBeanDefinitionParser { @@ -42,18 +47,15 @@ class CacheServerParser extends AbstractSimpleBeanDefinitionParser { @Override protected String resolveId(Element element, AbstractBeanDefinition definition, ParserContext parserContext) - throws BeanDefinitionStoreException { + throws BeanDefinitionStoreException { String name = super.resolveId(element, definition, parserContext); - if (!StringUtils.hasText(name)) { - name = "gemfireServer"; - } - return name; + return (StringUtils.hasText(name) ? name : "gemfireServer"); } @Override protected boolean isEligibleAttribute(Attr attribute, ParserContext parserContext) { - return super.isEligibleAttribute(attribute, parserContext) && !"groups".equals(attribute.getName()) - && !"cache-ref".equals(attribute.getName()); + return (super.isEligibleAttribute(attribute, parserContext) && !"groups".equals(attribute.getName()) + && !"cache-ref".equals(attribute.getName())); } @Override @@ -69,10 +71,10 @@ class CacheServerParser extends AbstractSimpleBeanDefinitionParser { builder.addPropertyValue("serverGroups", StringUtils.commaDelimitedListToStringArray(groupsAttribute)); } - parseSubscription(builder, element); + parseSubscription(element, builder); } - private void parseSubscription(BeanDefinitionBuilder builder, Element element) { + private void parseSubscription(Element element, BeanDefinitionBuilder builder) { Element subscriptionConfigElement = DomUtils.getChildElementByTagName(element, "subscription-config"); if (subscriptionConfigElement != null) { @@ -82,7 +84,7 @@ class CacheServerParser extends AbstractSimpleBeanDefinitionParser { String evictionTypeAttribute = subscriptionConfigElement.getAttribute("eviction-type"); if (StringUtils.hasText(evictionTypeAttribute)) { - builder.addPropertyValue("subscriptionEvictionPolicy", evictionTypeAttribute.toUpperCase()); + builder.addPropertyValue("subscriptionEvictionPolicy", evictionTypeAttribute); } } } diff --git a/src/main/java/org/springframework/data/gemfire/server/CacheServerFactoryBean.java b/src/main/java/org/springframework/data/gemfire/server/CacheServerFactoryBean.java index 59036076..3d9d0c46 100644 --- a/src/main/java/org/springframework/data/gemfire/server/CacheServerFactoryBean.java +++ b/src/main/java/org/springframework/data/gemfire/server/CacheServerFactoryBean.java @@ -71,8 +71,7 @@ public class CacheServerFactoryBean implements FactoryBean, Initial private String[] serverGroups = {}; - private SubscriptionEvictionPolicy subscriptionEvictionPolicy = SubscriptionEvictionPolicy.valueOf( - ClientSubscriptionConfig.DEFAULT_EVICTION_POLICY.toUpperCase()); + private SubscriptionEvictionPolicy subscriptionEvictionPolicy = SubscriptionEvictionPolicy.DEFAULT; public CacheServer getObject() { return cacheServer; @@ -112,42 +111,43 @@ public class CacheServerFactoryBean implements FactoryBean, Initial ClientSubscriptionConfig config = cacheServer.getClientSubscriptionConfig(); config.setCapacity(subscriptionCapacity); - config.setEvictionPolicy(subscriptionEvictionPolicy.name().toLowerCase()); + getSubscriptionEvictionPolicy().setEvictionPolicy(config); if (StringUtils.hasText(subscriptionDiskStore)) { config.setDiskStoreName(subscriptionDiskStore); } } + public boolean isAutoStartup() { + return autoStartup; + } + + public boolean isRunning() { + return (cacheServer != null && cacheServer.isRunning()); + } + + public int getPhase() { + // start at the latest possible moment + return Integer.MAX_VALUE; + } + public void destroy() { stop(); cacheServer = null; } - public boolean isAutoStartup() { - return autoStartup; - } - - public void stop(Runnable callback) { - stop(); - callback.run(); - } - - public int getPhase() { - // start the latest - return Integer.MAX_VALUE; - } - - public boolean isRunning() { - return (cacheServer != null && cacheServer.isRunning()); - } - public void start() { try { cacheServer.start(); - } catch (IOException ex) { - throw new BeanInitializationException("Cannot start cache server", ex); } + catch (IOException e) { + throw new BeanInitializationException("Cannot start cache server", e); + } + } + + public void stop(final Runnable callback) { + stop(); + callback.run(); } public void stop() { @@ -160,54 +160,22 @@ public class CacheServerFactoryBean implements FactoryBean, Initial this.autoStartup = autoStartup; } - public void setPort(int port) { - this.port = port; - } - - public void setMaxConnections(int maxConnections) { - this.maxConnections = maxConnections; - } - - public void setMaxThreads(int maxThreads) { - this.maxThreads = maxThreads; - } - - public void setNotifyBySubscription(boolean notifyBySubscription) { - this.notifyBySubscription = notifyBySubscription; - } - - public void setSocketBufferSize(int socketBufferSize) { - this.socketBufferSize = socketBufferSize; - } - - public void setMaxTimeBetweenPings(int maxTimeBetweenPings) { - this.maxTimeBetweenPings = maxTimeBetweenPings; - } - - public void setMaxMessageCount(int maxMessageCount) { - this.maxMessageCount = maxMessageCount; - } - - public void setMessageTimeToLive(int messageTimeToLive) { - this.messageTimeToLive = messageTimeToLive; - } - - public void setServerGroups(String[] serverGroups) { - this.serverGroups = serverGroups; - } - - public void setServerLoadProbe(ServerLoadProbe serverLoadProbe) { - this.serverLoadProbe = serverLoadProbe; - } - - public void setLoadPollInterval(long loadPollInterval) { - this.loadPollInterval = loadPollInterval; - } - public void setBindAddress(String bindAddress) { this.bindAddress = bindAddress; } + public void setCache(final Cache cache) { + this.cache = cache; + } + + /* + * (non-Javadoc) + * For testing purposes only! + */ + void setCacheServer(final CacheServer cacheServer) { + this.cacheServer = cacheServer; + } + public void setHostNameForClients(String hostNameForClients) { this.hostNameForClients = hostNameForClients; } @@ -216,20 +184,50 @@ public class CacheServerFactoryBean implements FactoryBean, Initial this.listeners = listeners; } - public void setCache(Cache cache) { - this.cache = cache; + public void setLoadPollInterval(long loadPollInterval) { + this.loadPollInterval = loadPollInterval; } - /** - * @param evictionPolicy the subscriptionEvictionPolicy to set - */ - public void setSubscriptionEvictionPolicy(SubscriptionEvictionPolicy evictionPolicy) { - this.subscriptionEvictionPolicy = evictionPolicy; + public void setMaxConnections(int maxConnections) { + this.maxConnections = maxConnections; + } + + public void setMaxMessageCount(int maxMessageCount) { + this.maxMessageCount = maxMessageCount; + } + + public void setMaxThreads(int maxThreads) { + this.maxThreads = maxThreads; + } + + public void setMaxTimeBetweenPings(int maxTimeBetweenPings) { + this.maxTimeBetweenPings = maxTimeBetweenPings; + } + + public void setMessageTimeToLive(int messageTimeToLive) { + this.messageTimeToLive = messageTimeToLive; + } + + public void setNotifyBySubscription(boolean notifyBySubscription) { + this.notifyBySubscription = notifyBySubscription; + } + + public void setPort(int port) { + this.port = port; + } + + public void setServerGroups(String[] serverGroups) { + this.serverGroups = serverGroups; + } + + public void setServerLoadProbe(ServerLoadProbe serverLoadProbe) { + this.serverLoadProbe = serverLoadProbe; + } + + public void setSocketBufferSize(int socketBufferSize) { + this.socketBufferSize = socketBufferSize; } - /** - * @param subscriptionCapacity the subscriptionCapacity to set - */ public void setSubscriptionCapacity(int subscriptionCapacity) { this.subscriptionCapacity = subscriptionCapacity; } @@ -238,4 +236,12 @@ public class CacheServerFactoryBean implements FactoryBean, Initial this.subscriptionDiskStore = diskStoreName; } + SubscriptionEvictionPolicy getSubscriptionEvictionPolicy() { + return (subscriptionEvictionPolicy != null ? subscriptionEvictionPolicy : SubscriptionEvictionPolicy.DEFAULT); + } + + public void setSubscriptionEvictionPolicy(SubscriptionEvictionPolicy evictionPolicy) { + this.subscriptionEvictionPolicy = evictionPolicy; + } + } diff --git a/src/main/java/org/springframework/data/gemfire/server/SubscriptionEvictionPolicy.java b/src/main/java/org/springframework/data/gemfire/server/SubscriptionEvictionPolicy.java index 64252845..236823a7 100644 --- a/src/main/java/org/springframework/data/gemfire/server/SubscriptionEvictionPolicy.java +++ b/src/main/java/org/springframework/data/gemfire/server/SubscriptionEvictionPolicy.java @@ -17,12 +17,59 @@ package org.springframework.data.gemfire.server; import com.gemstone.gemfire.cache.server.CacheServer; +import com.gemstone.gemfire.cache.server.ClientSubscriptionConfig; /** * Enumeration of the various client subscription policies for {@link CacheServer}. * * @author Costin Leau + * @author John Blum + * @since 1.1.0 */ public enum SubscriptionEvictionPolicy { - NONE, MEM, ENTRY + ENTRY, + MEM, + NONE; + + public static final SubscriptionEvictionPolicy DEFAULT = SubscriptionEvictionPolicy.valueOfIgnoreCase( + ClientSubscriptionConfig.DEFAULT_EVICTION_POLICY); + + /** + * Returns the value of the given String name as a SubscriptionEvictionPolicy enum using a case-insensitive, + * equality comparison. + * + * @param name the String name of a SubscriptionEvictionPolicy enumerated value. + * @return a SubscriptionEvictionPolicy enumerated value given a String name or null if no enum value + * with name was found. + * @see org.springframework.data.gemfire.server.SubscriptionEvictionPolicy + * @see java.lang.String#equalsIgnoreCase(String) + * @see #values() + * @see #name() + */ + public static SubscriptionEvictionPolicy valueOfIgnoreCase(final String name) { + for (SubscriptionEvictionPolicy subscriptionEvictionPolicy : values()) { + if (subscriptionEvictionPolicy.name().equalsIgnoreCase(name)) { + return subscriptionEvictionPolicy; + } + } + + return null; + } + + /** + * Null-safe utility method for setting the client's subscription eviction policy on the configuration meta-data. + * + * @param config a GemFire ClientSubscriptionConfig object holding the configuration setting and meta-data + * about the client's subscription configuration. + * @return the ClientSubscriptionConfig object. + * @see com.gemstone.gemfire.cache.server.ClientSubscriptionConfig#setEvictionPolicy(String) + */ + public ClientSubscriptionConfig setEvictionPolicy(final ClientSubscriptionConfig config) { + if (config != null) { + config.setEvictionPolicy(name().toLowerCase()); + } + + return config; + } + } diff --git a/src/main/java/org/springframework/data/gemfire/server/SubscriptionEvictionPolicyConverter.java b/src/main/java/org/springframework/data/gemfire/server/SubscriptionEvictionPolicyConverter.java new file mode 100644 index 00000000..1e1dfdc6 --- /dev/null +++ b/src/main/java/org/springframework/data/gemfire/server/SubscriptionEvictionPolicyConverter.java @@ -0,0 +1,49 @@ +/* + * 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.server; + +import org.springframework.data.gemfire.support.AbstractPropertyEditorConverterSupport; + +/** + * The SubscriptionEvictionPolicyConverter class is a Spring Converter and JavaBeans PropertyEditor for converting + * Strings into a SubscriptionEvictionPolicy enumerated value. + * + * @author John Blum + * @see org.springframework.data.gemfire.server.SubscriptionEvictionPolicy + * @see org.springframework.data.gemfire.support.AbstractPropertyEditorConverterSupport + * @since 1.6.0 + */ +@SuppressWarnings("unused") +public class SubscriptionEvictionPolicyConverter extends AbstractPropertyEditorConverterSupport { + + /** + * Converts the given String into a SubscriptionEvictionPolicy enumerated value. + * + * @param source the String to convert into a SubscriptionEvictionPolicy enum. + * @return a SubscriptionEvictionPolicy enumerated value for the given String. + * @throws java.lang.IllegalArgumentException if the String is a valid SubscriptionEvictionPolicy + * enumerated value. + * @see org.springframework.data.gemfire.server.SubscriptionEvictionPolicy#valueOfIgnoreCase(String) + * @see #assertConverted(String, Object, Class) + */ + @Override + public SubscriptionEvictionPolicy convert(final String source) { + return assertConverted(source, SubscriptionEvictionPolicy.valueOfIgnoreCase(source), + SubscriptionEvictionPolicy.class); + } + +} diff --git a/src/main/resources/org/springframework/data/gemfire/config/spring-gemfire-1.6.xsd b/src/main/resources/org/springframework/data/gemfire/config/spring-gemfire-1.6.xsd index f49617ce..e526d9dd 100644 --- a/src/main/resources/org/springframework/data/gemfire/config/spring-gemfire-1.6.xsd +++ b/src/main/resources/org/springframework/data/gemfire/config/spring-gemfire-1.6.xsd @@ -2122,17 +2122,8 @@ The client subscription configuration that is used to control a clients use of s ]]> - - - - - - - - - - + + diff --git a/src/test/java/org/springframework/data/gemfire/server/CacheServerFactoryBeanTest.java b/src/test/java/org/springframework/data/gemfire/server/CacheServerFactoryBeanTest.java new file mode 100644 index 00000000..b7bbb50e --- /dev/null +++ b/src/test/java/org/springframework/data/gemfire/server/CacheServerFactoryBeanTest.java @@ -0,0 +1,233 @@ +/* + * 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.server; + +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.eq; +import static org.mockito.Matchers.same; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import java.io.IOException; +import java.util.Arrays; +import java.util.HashSet; +import java.util.concurrent.atomic.AtomicBoolean; + +import org.junit.Test; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; + +import com.gemstone.gemfire.cache.Cache; +import com.gemstone.gemfire.cache.InterestRegistrationListener; +import com.gemstone.gemfire.cache.server.CacheServer; +import com.gemstone.gemfire.cache.server.ClientSubscriptionConfig; +import com.gemstone.gemfire.cache.server.ServerLoadProbe; + +/** + * The CacheServerFactoryBeanTest class is a test suite of test cases testing the contract and functionality + * of the CacheServerFactoryBean class. + * + * @author John Blum + * @see org.junit.Test + * @see org.springframework.data.gemfire.server.CacheServerFactoryBean + * @since 1.6.0 + */ +public class CacheServerFactoryBeanTest { + + @Test + public void testGetObjectUninitialized() { + assertNull(new CacheServerFactoryBean().getObject()); + } + + @Test + public void testGetObjectType() { + assertEquals(CacheServer.class, new CacheServerFactoryBean().getObjectType()); + } + + @Test + public void testIsSingleton() { + assertTrue(new CacheServerFactoryBean().isSingleton()); + } + + @Test + @SuppressWarnings("deprecation") + public void testAfterPropertiesSet() throws IOException { + Cache mockCache = mock(Cache.class, "testAfterPropertiesSet.MockCache"); + + CacheServer mockCacheServer = mock(CacheServer.class, "testAfterPropertiesSet.MockCacheServer"); + + ClientSubscriptionConfig mockClientSubscriptionConfig = mock(ClientSubscriptionConfig.class, + "testAfterPropertiesSet.MockClientSubscriptionConfig"); + + InterestRegistrationListener mockInterestRegistrationListenerOne = mock(InterestRegistrationListener.class, + "testAfterPropertiesSet.MockInterestRegistrationListener.One"); + + InterestRegistrationListener mockInterestRegistrationListenerTwo = mock(InterestRegistrationListener.class, + "testAfterPropertiesSet.MockInterestRegistrationListener.Two"); + + ServerLoadProbe mockServerLoadProbe = mock(ServerLoadProbe.class, "testAfterPropertiesSet.MockServerLoadProbe"); + + when(mockCache.addCacheServer()).thenReturn(mockCacheServer); + when(mockCacheServer.getClientSubscriptionConfig()).thenReturn(mockClientSubscriptionConfig); + + CacheServerFactoryBean factoryBean = new CacheServerFactoryBean(); + + factoryBean.setCache(mockCache); + factoryBean.setBindAddress("10.124.62.5"); + factoryBean.setHostNameForClients("skullbox"); + factoryBean.setListeners(new HashSet(Arrays.asList( + mockInterestRegistrationListenerOne, mockInterestRegistrationListenerTwo))); + factoryBean.setLoadPollInterval(500l); + factoryBean.setMaxConnections(200); + factoryBean.setMaxMessageCount(1024); + factoryBean.setMaxTimeBetweenPings(2000); + factoryBean.setMaxThreads(50); + factoryBean.setMessageTimeToLive(8192); + factoryBean.setNotifyBySubscription(true); + factoryBean.setPort(54321); + factoryBean.setServerGroups(new String[] { "testGroup" }); + factoryBean.setServerLoadProbe(mockServerLoadProbe); + factoryBean.setSocketBufferSize(4096); + factoryBean.setSubscriptionCapacity(8196); + factoryBean.setSubscriptionEvictionPolicy(SubscriptionEvictionPolicy.ENTRY); + factoryBean.setSubscriptionDiskStore("toTheVoid"); + factoryBean.afterPropertiesSet(); + + assertSame(mockCacheServer, factoryBean.getObject()); + assertEquals(mockCacheServer.getClass(), factoryBean.getObjectType()); + + verify(mockCache, times(1)).addCacheServer(); + verify(mockCacheServer, times(1)).setBindAddress(eq("10.124.62.5")); + verify(mockCacheServer, times(1)).setGroups(eq(new String[] { "testGroup" })); + verify(mockCacheServer, times(1)).setHostnameForClients(eq("skullbox")); + verify(mockCacheServer, times(1)).setLoadPollInterval(eq(500l)); + verify(mockCacheServer, times(1)).setLoadProbe(same(mockServerLoadProbe)); + verify(mockCacheServer, times(1)).setMaxConnections(eq(200)); + verify(mockCacheServer, times(1)).setMaximumMessageCount(eq(1024)); + verify(mockCacheServer, times(1)).setMaximumTimeBetweenPings(eq(2000)); + verify(mockCacheServer, times(1)).setMaxThreads(eq(50)); + verify(mockCacheServer, times(1)).setMessageTimeToLive(eq(8192)); + verify(mockCacheServer, times(1)).setNotifyBySubscription(eq(true)); + verify(mockCacheServer, times(1)).setPort(eq(54321)); + verify(mockCacheServer, times(1)).setSocketBufferSize(eq(4096)); + verify(mockCacheServer, times(1)).registerInterestRegistrationListener( + same(mockInterestRegistrationListenerOne)); + verify(mockCacheServer, times(1)).registerInterestRegistrationListener( + same(mockInterestRegistrationListenerTwo)); + verify(mockCacheServer, times(1)).getClientSubscriptionConfig(); + verify(mockClientSubscriptionConfig, times(1)).setCapacity(eq(8196)); + verify(mockClientSubscriptionConfig, times(1)).setDiskStoreName(eq("toTheVoid")); + verify(mockClientSubscriptionConfig, times(1)).setEvictionPolicy("entry"); + } + + @Test(expected = IllegalArgumentException.class) + public void testAfterPropertiesSetWithNullCache() throws IOException { + try { + new CacheServerFactoryBean().afterPropertiesSet(); + } + catch (IllegalArgumentException expected) { + assertEquals("A GemFire Cache is required.", expected.getMessage()); + throw expected; + } + } + + @Test + public void testSetAndGetAutoStartup() { + CacheServerFactoryBean factoryBean = new CacheServerFactoryBean(); + + assertTrue(factoryBean.isAutoStartup()); + + factoryBean.setAutoStartup(false); + + assertFalse(factoryBean.isAutoStartup()); + } + + @Test + public void testSetAndGetSubscriptionEvictionPolicy() { + CacheServerFactoryBean factoryBean = new CacheServerFactoryBean(); + + assertEquals(SubscriptionEvictionPolicy.DEFAULT, factoryBean.getSubscriptionEvictionPolicy()); + + factoryBean.setSubscriptionEvictionPolicy(SubscriptionEvictionPolicy.MEM); + + assertEquals(SubscriptionEvictionPolicy.MEM, factoryBean.getSubscriptionEvictionPolicy()); + + factoryBean.setSubscriptionEvictionPolicy(null); + + assertEquals(SubscriptionEvictionPolicy.DEFAULT, factoryBean.getSubscriptionEvictionPolicy()); + } + + @Test + public void testCacheServerLifecycle() throws Exception { + CacheServer mockCacheServer = mock(CacheServer.class, "testCacheServerLifecycle.MockCacheServer"); + + final AtomicBoolean running = new AtomicBoolean(false); + final AtomicBoolean called = new AtomicBoolean(false); + + doAnswer(new Answer() { + @Override + public Object answer(final InvocationOnMock invocationOnMock) throws Throwable { + running.compareAndSet(false, true); + return null; + } + }).when(mockCacheServer).start(); + + doAnswer(new Answer() { + @Override + public Object answer(final InvocationOnMock invocationOnMock) throws Throwable { + running.compareAndSet(true, false); + return null; + } + }).when(mockCacheServer).stop(); + + when(mockCacheServer.isRunning()).then(new Answer() { + @Override + public Boolean answer(final InvocationOnMock invocationOnMock) throws Throwable { + return running.get(); + } + }); + + CacheServerFactoryBean factoryBean = new CacheServerFactoryBean(); + + factoryBean.setCacheServer(mockCacheServer); + + assertSame(mockCacheServer, factoryBean.getObject()); + assertFalse(factoryBean.isRunning()); + + factoryBean.start(); + + assertTrue(factoryBean.isRunning()); + assertFalse(called.get()); + + factoryBean.stop(new Runnable() { + @Override public void run() { + called.set(true); + } + }); + + assertFalse(factoryBean.isRunning()); + assertTrue(called.get()); + } + +} diff --git a/src/test/java/org/springframework/data/gemfire/server/SubscriptionEvictionPolicyConverterTest.java b/src/test/java/org/springframework/data/gemfire/server/SubscriptionEvictionPolicyConverterTest.java new file mode 100644 index 00000000..e79d9a02 --- /dev/null +++ b/src/test/java/org/springframework/data/gemfire/server/SubscriptionEvictionPolicyConverterTest.java @@ -0,0 +1,87 @@ +/* + * 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.server; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; + +import org.junit.After; +import org.junit.Test; + +/** + * The SubscriptionEvictionPolicyConverterTest class is a test suite of test cases testing the contract + * and functionality of the SubscriptionEvictionPolicyConverter class. + * + * @author John Blum + * @see org.junit.Test + * @see org.springframework.data.gemfire.server.SubscriptionEvictionPolicy + * @see org.springframework.data.gemfire.server.SubscriptionEvictionPolicyConverter + * @since 1.6.0 + */ +public class SubscriptionEvictionPolicyConverterTest { + + private final SubscriptionEvictionPolicyConverter converter = new SubscriptionEvictionPolicyConverter(); + + @After + public void tearDown() { + converter.setValue(null); + } + + @Test + public void testConvert() { + assertEquals(SubscriptionEvictionPolicy.ENTRY, converter.convert("EnTry")); + assertEquals(SubscriptionEvictionPolicy.MEM, converter.convert("MEM")); + assertEquals(SubscriptionEvictionPolicy.NONE, converter.convert("nONE")); + assertEquals(SubscriptionEvictionPolicy.NONE, converter.convert("NOne")); + } + + @Test(expected = IllegalArgumentException.class) + public void testConvertIllegalValue() { + try { + converter.setAsText("memory"); + } + catch (IllegalArgumentException expected) { + assertEquals("(memory) is not a valid SubscriptionEvictionPolicy!", expected.getMessage()); + throw expected; + } + } + + @Test + public void testSetAsText() { + assertNull(converter.getValue()); + converter.setAsText("enTRY"); + assertEquals(SubscriptionEvictionPolicy.ENTRY, converter.getValue()); + converter.setAsText("MEm"); + assertEquals(SubscriptionEvictionPolicy.MEM, converter.getValue()); + } + + @Test(expected = IllegalArgumentException.class) + public void testSetAsTextWithIllegalValue() { + try { + assertNull(converter.getValue()); + converter.setAsText("KEYS"); + } + catch (IllegalArgumentException expected) { + assertEquals("(KEYS) is not a valid SubscriptionEvictionPolicy!", expected.getMessage()); + throw expected; + } + finally { + assertNull(converter.getValue()); + } + } + +} diff --git a/src/test/java/org/springframework/data/gemfire/server/SubscriptionEvictionPolicyTest.java b/src/test/java/org/springframework/data/gemfire/server/SubscriptionEvictionPolicyTest.java new file mode 100644 index 00000000..5b777c29 --- /dev/null +++ b/src/test/java/org/springframework/data/gemfire/server/SubscriptionEvictionPolicyTest.java @@ -0,0 +1,87 @@ +/* + * 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.server; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertSame; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; + +import org.junit.Test; + +import com.gemstone.gemfire.cache.server.ClientSubscriptionConfig; + +/** + * The SubscriptionEvictionPolicyTest class is a test suite of test cases testing the contract and functionality + * of the SubscriptionEvictionPolicy enum. + * + * @author John Blum + * @see org.junit.Test + * @see org.springframework.data.gemfire.server.SubscriptionEvictionPolicy + * @since 1.6.0 + */ +public class SubscriptionEvictionPolicyTest { + + @Test + public void testDefault() { + assertEquals(ClientSubscriptionConfig.DEFAULT_EVICTION_POLICY.toLowerCase(), + SubscriptionEvictionPolicy.DEFAULT.name().toLowerCase()); + assertSame(SubscriptionEvictionPolicy.NONE, SubscriptionEvictionPolicy.DEFAULT); + } + + @Test + public void testValueOfIgnoreCase() { + assertEquals(SubscriptionEvictionPolicy.ENTRY, SubscriptionEvictionPolicy.valueOfIgnoreCase("entry")); + assertEquals(SubscriptionEvictionPolicy.MEM, SubscriptionEvictionPolicy.valueOfIgnoreCase("Mem")); + assertEquals(SubscriptionEvictionPolicy.NONE, SubscriptionEvictionPolicy.valueOfIgnoreCase("NOne")); + assertEquals(SubscriptionEvictionPolicy.NONE, SubscriptionEvictionPolicy.valueOfIgnoreCase("nONE")); + assertEquals(SubscriptionEvictionPolicy.NONE, SubscriptionEvictionPolicy.valueOfIgnoreCase("NONE")); + } + + @Test + public void testValueOfIgnoreCaseWithIllegalValue() { + assertNull(SubscriptionEvictionPolicy.valueOfIgnoreCase("KEYS")); + assertNull(SubscriptionEvictionPolicy.valueOfIgnoreCase("Memory")); + assertNull(SubscriptionEvictionPolicy.valueOfIgnoreCase("all")); + assertNull(SubscriptionEvictionPolicy.valueOfIgnoreCase("no")); + assertNull(SubscriptionEvictionPolicy.valueOfIgnoreCase("one")); + assertNull(SubscriptionEvictionPolicy.valueOfIgnoreCase(" ")); + assertNull(SubscriptionEvictionPolicy.valueOfIgnoreCase("")); + assertNull(SubscriptionEvictionPolicy.valueOfIgnoreCase(null)); + } + + @Test + public void testSetEvictionPolicy() { + ClientSubscriptionConfig mockConfig = mock(ClientSubscriptionConfig.class, + "testSetEvictionPolicy.ClientSubscriptionConfig"); + + ClientSubscriptionConfig returnedConfig = SubscriptionEvictionPolicy.MEM.setEvictionPolicy(mockConfig); + + assertSame(mockConfig, returnedConfig); + + verify(mockConfig, times(1)).setEvictionPolicy(eq("mem")); + } + + @Test + public void testSetEvictionPolicyWithNull() { + assertNull(SubscriptionEvictionPolicy.ENTRY.setEvictionPolicy(null)); + } + +} diff --git a/src/test/resources/org/springframework/data/gemfire/config/server-ns.xml b/src/test/resources/org/springframework/data/gemfire/config/server-ns.xml index 04a78435..918bdbd1 100644 --- a/src/test/resources/org/springframework/data/gemfire/config/server-ns.xml +++ b/src/test/resources/org/springframework/data/gemfire/config/server-ns.xml @@ -11,23 +11,28 @@ http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd "> + + 40406 + ENTRY + + + + - ServerNamespaceConfig + CacheServerNamespaceTest 0 warning - - - - +