diff --git a/src/main/java/org/springframework/data/gemfire/function/config/AbstractFunctionExecutionConfigurationSource.java b/src/main/java/org/springframework/data/gemfire/function/config/AbstractFunctionExecutionConfigurationSource.java index 66637cc4..43a52e31 100644 --- a/src/main/java/org/springframework/data/gemfire/function/config/AbstractFunctionExecutionConfigurationSource.java +++ b/src/main/java/org/springframework/data/gemfire/function/config/AbstractFunctionExecutionConfigurationSource.java @@ -26,8 +26,8 @@ import java.util.Set; import java.util.stream.Collectors; import java.util.stream.StreamSupport; -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider; import org.springframework.context.annotation.ScannedGenericBeanDefinition; import org.springframework.core.io.ResourceLoader; @@ -50,7 +50,7 @@ import org.springframework.data.gemfire.function.annotation.OnServers; * @author John Blum * @see org.springframework.data.gemfire.function.config.FunctionExecutionConfiguration */ -abstract class AbstractFunctionExecutionConfigurationSource implements FunctionExecutionConfigurationSource { +public abstract class AbstractFunctionExecutionConfigurationSource implements FunctionExecutionConfigurationSource { private static Set> functionExecutionAnnotationTypes; @@ -67,15 +67,15 @@ abstract class AbstractFunctionExecutionConfigurationSource implements FunctionE functionExecutionAnnotationTypes = Collections.unmodifiableSet(annotationTypes); } - static Set> getFunctionExecutionAnnotationTypes() { + public static Set> getFunctionExecutionAnnotationTypes() { return functionExecutionAnnotationTypes; } - static Set getFunctionExecutionAnnotationTypeNames() { + public static Set getFunctionExecutionAnnotationTypeNames() { return getFunctionExecutionAnnotationTypes().stream().map(Class::getName).collect(Collectors.toSet()); } - protected Log logger = LogFactory.getLog(getClass()); + protected Logger logger = LoggerFactory.getLogger(getClass()); public Collection getCandidates(ResourceLoader loader) { diff --git a/src/main/java/org/springframework/data/gemfire/function/config/AnnotationFunctionExecutionConfigurationSource.java b/src/main/java/org/springframework/data/gemfire/function/config/AnnotationFunctionExecutionConfigurationSource.java index e60467ef..af41a37d 100644 --- a/src/main/java/org/springframework/data/gemfire/function/config/AnnotationFunctionExecutionConfigurationSource.java +++ b/src/main/java/org/springframework/data/gemfire/function/config/AnnotationFunctionExecutionConfigurationSource.java @@ -12,6 +12,8 @@ */ package org.springframework.data.gemfire.function.config; +import static org.springframework.data.gemfire.util.ArrayUtils.nullSafeArray; + import java.lang.annotation.Annotation; import java.util.ArrayList; import java.util.Arrays; @@ -27,6 +29,7 @@ import org.springframework.core.type.AnnotationMetadata; import org.springframework.core.type.filter.AnnotationTypeFilter; import org.springframework.core.type.filter.AssignableTypeFilter; import org.springframework.core.type.filter.TypeFilter; +import org.springframework.data.gemfire.util.ArrayUtils; import org.springframework.util.Assert; import org.springframework.util.ClassUtils; @@ -36,10 +39,11 @@ import org.springframework.util.ClassUtils; * @author David Turanski * */ -class AnnotationFunctionExecutionConfigurationSource extends AbstractFunctionExecutionConfigurationSource { +public class AnnotationFunctionExecutionConfigurationSource extends AbstractFunctionExecutionConfigurationSource { private static final String BASE_PACKAGES = "basePackages"; private static final String BASE_PACKAGE_CLASSES = "basePackageClasses"; + private static final String VALUE = "value"; private final AnnotationMetadata metadata; private final AnnotationAttributes attributes; @@ -51,13 +55,14 @@ class AnnotationFunctionExecutionConfigurationSource extends AbstractFunctionExe * * @param metadata must not be {@literal null}. */ - AnnotationFunctionExecutionConfigurationSource(AnnotationMetadata metadata) { + public AnnotationFunctionExecutionConfigurationSource(AnnotationMetadata metadata) { - Assert.notNull(metadata); + Assert.notNull(metadata, "AnnotationMetadata must not be null"); + + this.attributes = AnnotationAttributes.fromMap( + metadata.getAnnotationAttributes(EnableGemfireFunctionExecutions.class.getName())); - this.attributes = new AnnotationAttributes(metadata.getAnnotationAttributes(EnableGemfireFunctionExecutions.class.getName())); this.metadata = metadata; - } @@ -67,7 +72,6 @@ class AnnotationFunctionExecutionConfigurationSource extends AbstractFunctionExe */ @Override public Object getSource() { - // TODO Auto-generated method stub return this.metadata; } @@ -76,27 +80,42 @@ class AnnotationFunctionExecutionConfigurationSource extends AbstractFunctionExe */ @Override public Iterable getBasePackages() { - String[] value = attributes.getStringArray("value"); - String[] basePackages = attributes.getStringArray(BASE_PACKAGES); - Class[] basePackageClasses = attributes.getClassArray(BASE_PACKAGE_CLASSES); + + String[] value = this.attributes.getStringArray(VALUE); + String[] basePackages = this.attributes.getStringArray(BASE_PACKAGES); + + Class[] basePackageClasses = this.attributes.getClassArray(BASE_PACKAGE_CLASSES); // Default configuration - return package of annotated class - if (value.length == 0 && basePackages.length == 0 && basePackageClasses.length == 0) { - String className = metadata.getClassName(); + if (areAllEmpty(value, basePackages, basePackageClasses)) { + + String className = this.metadata.getClassName(); + return Collections.singleton(className.substring(0, className.lastIndexOf('.'))); } - Set packages = new HashSet(); + Set packages = new HashSet<>(); + packages.addAll(Arrays.asList(value)); packages.addAll(Arrays.asList(basePackages)); - for (Class typeName : basePackageClasses) { - packages.add(ClassUtils.getPackageName(typeName)); - } + Arrays.stream(nullSafeArray(basePackageClasses, Class.class)) + .map(ClassUtils::getPackageName) + .forEach(packages::add); return packages; } + private boolean areAllEmpty(Object[]... arrays) { + + for (Object[] array : arrays) { + if (!ArrayUtils.isEmpty(array)) { + return false; + } + } + + return true; + } @Override public Iterable getIncludeFilters() { diff --git a/src/main/java/org/springframework/data/gemfire/function/config/FunctionExecutionBeanDefinitionRegistrar.java b/src/main/java/org/springframework/data/gemfire/function/config/FunctionExecutionBeanDefinitionRegistrar.java index 317d224f..91e0461e 100644 --- a/src/main/java/org/springframework/data/gemfire/function/config/FunctionExecutionBeanDefinitionRegistrar.java +++ b/src/main/java/org/springframework/data/gemfire/function/config/FunctionExecutionBeanDefinitionRegistrar.java @@ -30,18 +30,26 @@ import org.springframework.context.annotation.ScannedGenericBeanDefinition; import org.springframework.core.annotation.AnnotationAttributes; import org.springframework.core.io.DefaultResourceLoader; import org.springframework.core.type.AnnotationMetadata; +import org.springframework.data.gemfire.function.annotation.OnMember; +import org.springframework.data.gemfire.function.annotation.OnMembers; +import org.springframework.data.gemfire.function.annotation.OnRegion; +import org.springframework.data.gemfire.function.annotation.OnServer; +import org.springframework.data.gemfire.function.annotation.OnServers; import org.springframework.util.Assert; import org.springframework.util.StringUtils; import org.w3c.dom.Element; /** - * {@link ImportBeanDefinitionRegistrar} for {code} @EnableGemfireFunctionExecutions {code} - * Scans for interfaces annotated with one of {code} @OnRegion, @OnServer, @OnServers, @OnMember, @OnMembers {code} + * {@link ImportBeanDefinitionRegistrar} for {@link EnableGemfireFunctionExecutions}, which scans for interfaces + * annotated with one of {@link OnRegion}, {@link OnServer}, {@link OnServers}, {@link OnMember}, {@link OnMembers}. * * @author David Turanski * @author John Blum + * @see org.springframework.beans.factory.support.BeanDefinitionRegistry + * @see org.springframework.context.annotation.ImportBeanDefinitionRegistrar + * @see org.springframework.context.annotation.ScannedGenericBeanDefinition */ -class FunctionExecutionBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar { +public class FunctionExecutionBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar { /* * (non-Javadoc) @@ -52,20 +60,32 @@ class FunctionExecutionBeanDefinitionRegistrar implements ImportBeanDefinitionRe public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry registry) { AbstractFunctionExecutionConfigurationSource configurationSource = - new AnnotationFunctionExecutionConfigurationSource(annotationMetadata); + newAnnotationBasedFunctionExecutionConfigurationSource(annotationMetadata); registerBeanDefinitions(configurationSource, registry); } - void registerBeanDefinitions(Element element, ParserContext parserContext) { + protected AbstractFunctionExecutionConfigurationSource newAnnotationBasedFunctionExecutionConfigurationSource( + AnnotationMetadata annotationMetadata) { + + return new AnnotationFunctionExecutionConfigurationSource(annotationMetadata); + } + + protected void registerBeanDefinitions(Element element, ParserContext parserContext) { AbstractFunctionExecutionConfigurationSource configurationSource = - new XmlFunctionExecutionConfigurationSource(element, parserContext); + newXmlBasedFunctionExecutionConfigurationSource(element, parserContext); registerBeanDefinitions(configurationSource, parserContext.getRegistry()); } + protected AbstractFunctionExecutionConfigurationSource newXmlBasedFunctionExecutionConfigurationSource( + Element element, ParserContext parserContext) { + + return new XmlFunctionExecutionConfigurationSource(element, parserContext); + } + /** * Registers bean definitions from any {@link FunctionExecutionConfigurationSource}. */ diff --git a/src/main/java/org/springframework/data/gemfire/function/config/FunctionExecutionConfigurationSource.java b/src/main/java/org/springframework/data/gemfire/function/config/FunctionExecutionConfigurationSource.java index a89bba95..e452151a 100644 --- a/src/main/java/org/springframework/data/gemfire/function/config/FunctionExecutionConfigurationSource.java +++ b/src/main/java/org/springframework/data/gemfire/function/config/FunctionExecutionConfigurationSource.java @@ -21,20 +21,13 @@ import java.lang.annotation.Annotation; import org.springframework.core.type.filter.TypeFilter; /** -<<<<<<< Updated upstream - * Interface for function execution configuration sources (e.g., annotation or XML configuration) to configure - * classpath scanning of annotated interfaces to implement proxies that invoke Gemfire functions - * - * @author David Turanski -======= * Interface for Function Execution configuration sources (e.g. {@link Annotation} or XML configuration) * to configure classpath scanning of annotated interfaces to implement proxies that invoke Functions. ->>>>>>> Stashed changes * * @author David Turanski * @author John Blum */ -interface FunctionExecutionConfigurationSource { +public interface FunctionExecutionConfigurationSource { /** * Returns the base packages the repository interfaces shall be found under. diff --git a/src/main/java/org/springframework/data/gemfire/function/config/MemberBasedExecutionBeanDefinitionBuilder.java b/src/main/java/org/springframework/data/gemfire/function/config/MemberBasedExecutionBeanDefinitionBuilder.java index 80a3228f..bea1a8fa 100644 --- a/src/main/java/org/springframework/data/gemfire/function/config/MemberBasedExecutionBeanDefinitionBuilder.java +++ b/src/main/java/org/springframework/data/gemfire/function/config/MemberBasedExecutionBeanDefinitionBuilder.java @@ -14,37 +14,39 @@ package org.springframework.data.gemfire.function.config; import org.springframework.beans.factory.support.BeanDefinitionBuilder; import org.springframework.beans.factory.support.BeanDefinitionRegistry; +import org.springframework.data.gemfire.function.annotation.OnMember; +import org.springframework.data.gemfire.function.annotation.OnMembers; import org.springframework.data.gemfire.function.execution.GemfireFunctionProxyFactoryBean; import org.springframework.util.StringUtils; /** - * A base class for OnMember and OnMembers function execution bean definition builders. + * Base class for {@link OnMember} and {@link OnMembers} Function execution + * {@link BeanDefinitionBuilder BeanDefinitionBuilders}. * * @author David Turanski - * + * @author John Blum + * @see org.springframework.data.gemfire.function.config.AbstractFunctionExecutionBeanDefinitionBuilder */ - abstract class MemberBasedExecutionBeanDefinitionBuilder extends AbstractFunctionExecutionBeanDefinitionBuilder { +abstract class MemberBasedExecutionBeanDefinitionBuilder extends AbstractFunctionExecutionBeanDefinitionBuilder { /** * @param configuration */ - public MemberBasedExecutionBeanDefinitionBuilder(FunctionExecutionConfiguration configuration) { + MemberBasedExecutionBeanDefinitionBuilder(FunctionExecutionConfiguration configuration) { super(configuration); } - - /* (non-Javadoc) * @see org.springframework.data.gemfire.function.config.AbstractFunctionExecutionBeanDefinitionBuilder#getGemfireFunctionOperationsBeanDefinitionBuilder(org.springframework.beans.factory.support.BeanDefinitionRegistry) */ @Override protected BeanDefinitionBuilder getGemfireFunctionOperationsBeanDefinitionBuilder(BeanDefinitionRegistry registry) { - BeanDefinitionBuilder functionTemplateBuilder = BeanDefinitionBuilder.genericBeanDefinition(getGemfireOperationsClass()); + BeanDefinitionBuilder functionTemplateBuilder = + BeanDefinitionBuilder.genericBeanDefinition(getGemfireOperationsClass()); String groups = (String)configuration.getAttribute("groups"); - if (StringUtils.hasText(groups)) { functionTemplateBuilder.addConstructorArgValue(StringUtils.commaDelimitedListToStringArray(groups)); } @@ -62,4 +64,5 @@ import org.springframework.util.StringUtils; } protected abstract Class getGemfireOperationsClass(); + } diff --git a/src/main/java/org/springframework/data/gemfire/function/config/ServerBasedExecutionBeanDefinitionBuilder.java b/src/main/java/org/springframework/data/gemfire/function/config/ServerBasedExecutionBeanDefinitionBuilder.java index 6a12d50d..6f2206d3 100644 --- a/src/main/java/org/springframework/data/gemfire/function/config/ServerBasedExecutionBeanDefinitionBuilder.java +++ b/src/main/java/org/springframework/data/gemfire/function/config/ServerBasedExecutionBeanDefinitionBuilder.java @@ -15,19 +15,22 @@ package org.springframework.data.gemfire.function.config; import org.springframework.beans.factory.support.BeanDefinitionBuilder; import org.springframework.beans.factory.support.BeanDefinitionRegistry; import org.springframework.data.gemfire.config.xml.GemfireConstants; +import org.springframework.data.gemfire.function.annotation.OnServer; +import org.springframework.data.gemfire.function.annotation.OnServers; import org.springframework.data.gemfire.function.execution.GemfireFunctionProxyFactoryBean; import org.springframework.util.Assert; import org.springframework.util.StringUtils; /** - * @author David Turanski + * Base class for {@link OnServer} and {@link OnServers} Function execution + * {@link BeanDefinitionBuilder BeanDefinitionBuilders}. * + * @author David Turanski + * @author John Blum + * @see org.springframework.data.gemfire.function.config.AbstractFunctionExecutionBeanDefinitionBuilder */ abstract class ServerBasedExecutionBeanDefinitionBuilder extends AbstractFunctionExecutionBeanDefinitionBuilder { - /** - * @param configuration - */ ServerBasedExecutionBeanDefinitionBuilder(FunctionExecutionConfiguration configuration) { super(configuration); } @@ -38,18 +41,19 @@ abstract class ServerBasedExecutionBeanDefinitionBuilder extends AbstractFunctio */ @Override protected BeanDefinitionBuilder getGemfireFunctionOperationsBeanDefinitionBuilder(BeanDefinitionRegistry registry) { - BeanDefinitionBuilder functionTemplateBuilder = BeanDefinitionBuilder.genericBeanDefinition( - getGemfireFunctionOperationsClass()); - String cache = (String) configuration.getAttribute("cache"); - String pool = (String) configuration.getAttribute("pool"); + BeanDefinitionBuilder functionTemplateBuilder = + BeanDefinitionBuilder.genericBeanDefinition(getGemfireFunctionOperationsClass()); - Assert.state(!(StringUtils.hasText(cache) && StringUtils.hasText(pool)), String.format( - "invalid configuration for interface %s; cannot specify both 'pool' and 'cache'", - configuration.getFunctionExecutionInterface().getName())); + String cache = (String) this.configuration.getAttribute("cache"); + String pool = (String) this.configuration.getAttribute("pool"); - functionTemplateBuilder.addConstructorArgReference(StringUtils.hasText(pool) ? pool - : (StringUtils.hasText(cache) ? cache : GemfireConstants.DEFAULT_GEMFIRE_CACHE_NAME)); + Assert.state(!(StringUtils.hasText(cache) && StringUtils.hasText(pool)), + String.format("Invalid configuration for interface [%s]; cannot specify both 'pool' and 'cache'", + this.configuration.getFunctionExecutionInterface().getName())); + + functionTemplateBuilder.addConstructorArgReference(StringUtils.hasText(pool) + ? pool : (StringUtils.hasText(cache) ? cache : GemfireConstants.DEFAULT_GEMFIRE_CACHE_NAME)); return functionTemplateBuilder; } diff --git a/src/main/java/org/springframework/data/gemfire/function/config/XmlFunctionExecutionConfigurationSource.java b/src/main/java/org/springframework/data/gemfire/function/config/XmlFunctionExecutionConfigurationSource.java index 857e6e05..f023f99f 100644 --- a/src/main/java/org/springframework/data/gemfire/function/config/XmlFunctionExecutionConfigurationSource.java +++ b/src/main/java/org/springframework/data/gemfire/function/config/XmlFunctionExecutionConfigurationSource.java @@ -29,7 +29,7 @@ import org.w3c.dom.Element; * @author David Turanski * */ -class XmlFunctionExecutionConfigurationSource extends AbstractFunctionExecutionConfigurationSource { +public class XmlFunctionExecutionConfigurationSource extends AbstractFunctionExecutionConfigurationSource { private static final String BASE_PACKAGE = "base-package"; @@ -40,7 +40,7 @@ class XmlFunctionExecutionConfigurationSource extends AbstractFunctionExecutionC private final ParserContext parserContext; - XmlFunctionExecutionConfigurationSource(Element element, ParserContext parserContext) { + public XmlFunctionExecutionConfigurationSource(Element element, ParserContext parserContext) { Assert.notNull(element, "Element must not be null"); Assert.notNull(parserContext, "ParserContext must not be null"); diff --git a/src/test/java/org/springframework/data/gemfire/function/config/ServerBasedExecutionBeanDefinitionBuilderTest.java b/src/test/java/org/springframework/data/gemfire/function/config/ServerBasedExecutionBeanDefinitionBuilderTest.java index ace01016..3b4169f6 100644 --- a/src/test/java/org/springframework/data/gemfire/function/config/ServerBasedExecutionBeanDefinitionBuilderTest.java +++ b/src/test/java/org/springframework/data/gemfire/function/config/ServerBasedExecutionBeanDefinitionBuilderTest.java @@ -31,8 +31,6 @@ import static org.mockito.Mockito.when; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; -import org.mockito.invocation.InvocationOnMock; -import org.mockito.stubbing.Answer; import org.springframework.beans.factory.config.RuntimeBeanReference; import org.springframework.beans.factory.support.AbstractBeanDefinition; import org.springframework.beans.factory.support.BeanDefinitionBuilder; @@ -56,22 +54,22 @@ public class ServerBasedExecutionBeanDefinitionBuilderTest { @Test @SuppressWarnings("unchecked") public void getGemfireFunctionOperationsBeanDefinitionBuilder() { + FunctionExecutionConfiguration mockFunctionExecutionConfiguration = mock(FunctionExecutionConfiguration.class, "MockFunctionExecutionConfiguration"); when(mockFunctionExecutionConfiguration.getAttribute(eq("cache"))).thenReturn(null); when(mockFunctionExecutionConfiguration.getAttribute(eq("pool"))).thenReturn(" "); - when(mockFunctionExecutionConfiguration.getFunctionExecutionInterface()).thenAnswer(new Answer>() { - @Override public Class answer(final InvocationOnMock invocation) throws Throwable { - return Object.class; - } - }); + when(mockFunctionExecutionConfiguration.getFunctionExecutionInterface()).thenAnswer(invocation -> Object.class); - ServerBasedExecutionBeanDefinitionBuilder builder = new ServerBasedExecutionBeanDefinitionBuilder(mockFunctionExecutionConfiguration) { - @Override protected Class getGemfireFunctionOperationsClass() { - return Object.class; - } - }; + ServerBasedExecutionBeanDefinitionBuilder builder = + new ServerBasedExecutionBeanDefinitionBuilder(mockFunctionExecutionConfiguration) { + + @Override + protected Class getGemfireFunctionOperationsClass() { + return Object.class; + } + }; BeanDefinitionBuilder beanDefinitionBuilder = builder.getGemfireFunctionOperationsBeanDefinitionBuilder(null); @@ -80,7 +78,7 @@ public class ServerBasedExecutionBeanDefinitionBuilderTest { AbstractBeanDefinition beanDefinition = beanDefinitionBuilder.getRawBeanDefinition(); assertThat(beanDefinition, is(notNullValue())); - assertThat((Class) beanDefinition.getBeanClass(), is(equalTo(Object.class))); + assertThat(beanDefinition.getBeanClass(), is(equalTo(Object.class))); assertThat(String.valueOf(beanDefinition.getConstructorArgumentValues() .getArgumentValue(0, RuntimeBeanReference.class).getValue()), containsString(GemfireConstants.DEFAULT_GEMFIRE_CACHE_NAME)); @@ -93,22 +91,22 @@ public class ServerBasedExecutionBeanDefinitionBuilderTest { @Test @SuppressWarnings("unchecked") public void getGemfireFunctionOperationsBeanDefinitionBuilderWithCache() { + FunctionExecutionConfiguration mockFunctionExecutionConfiguration = mock(FunctionExecutionConfiguration.class, "MockFunctionExecutionConfiguration"); when(mockFunctionExecutionConfiguration.getAttribute(eq("cache"))).thenReturn("TestCache"); when(mockFunctionExecutionConfiguration.getAttribute(eq("pool"))).thenReturn(" "); - when(mockFunctionExecutionConfiguration.getFunctionExecutionInterface()).thenAnswer(new Answer>() { - @Override public Class answer(final InvocationOnMock invocation) throws Throwable { - return Object.class; - } - }); + when(mockFunctionExecutionConfiguration.getFunctionExecutionInterface()).thenAnswer(invocation -> Object.class); - ServerBasedExecutionBeanDefinitionBuilder builder = new ServerBasedExecutionBeanDefinitionBuilder(mockFunctionExecutionConfiguration) { - @Override protected Class getGemfireFunctionOperationsClass() { - return Object.class; - } - }; + ServerBasedExecutionBeanDefinitionBuilder builder = + new ServerBasedExecutionBeanDefinitionBuilder(mockFunctionExecutionConfiguration) { + + @Override + protected Class getGemfireFunctionOperationsClass() { + return Object.class; + } + }; BeanDefinitionBuilder beanDefinitionBuilder = builder.getGemfireFunctionOperationsBeanDefinitionBuilder(null); @@ -117,7 +115,7 @@ public class ServerBasedExecutionBeanDefinitionBuilderTest { AbstractBeanDefinition beanDefinition = beanDefinitionBuilder.getRawBeanDefinition(); assertThat(beanDefinition, is(notNullValue())); - assertThat((Class) beanDefinition.getBeanClass(), is(equalTo(Object.class))); + assertThat(beanDefinition.getBeanClass(), is(equalTo(Object.class))); assertThat(String.valueOf(beanDefinition.getConstructorArgumentValues() .getArgumentValue(0, RuntimeBeanReference.class).getValue()), containsString("TestCache")); @@ -129,22 +127,22 @@ public class ServerBasedExecutionBeanDefinitionBuilderTest { @Test @SuppressWarnings("unchecked") public void getGemfireFunctionOperationsBeanDefinitionBuilderWithPool() { + FunctionExecutionConfiguration mockFunctionExecutionConfiguration = mock(FunctionExecutionConfiguration.class, "MockFunctionExecutionConfiguration"); when(mockFunctionExecutionConfiguration.getAttribute(eq("cache"))).thenReturn(null); when(mockFunctionExecutionConfiguration.getAttribute(eq("pool"))).thenReturn("TestPool"); - when(mockFunctionExecutionConfiguration.getFunctionExecutionInterface()).thenAnswer(new Answer>() { - @Override public Class answer(final InvocationOnMock invocation) throws Throwable { - return Object.class; - } - }); + when(mockFunctionExecutionConfiguration.getFunctionExecutionInterface()).thenAnswer(invocation -> Object.class); - ServerBasedExecutionBeanDefinitionBuilder builder = new ServerBasedExecutionBeanDefinitionBuilder(mockFunctionExecutionConfiguration) { - @Override protected Class getGemfireFunctionOperationsClass() { - return Object.class; - } - }; + ServerBasedExecutionBeanDefinitionBuilder builder = + new ServerBasedExecutionBeanDefinitionBuilder(mockFunctionExecutionConfiguration) { + + @Override + protected Class getGemfireFunctionOperationsClass() { + return Object.class; + } + }; BeanDefinitionBuilder beanDefinitionBuilder = builder.getGemfireFunctionOperationsBeanDefinitionBuilder(null); @@ -153,7 +151,7 @@ public class ServerBasedExecutionBeanDefinitionBuilderTest { AbstractBeanDefinition beanDefinition = beanDefinitionBuilder.getRawBeanDefinition(); assertThat(beanDefinition, is(notNullValue())); - assertThat((Class) beanDefinition.getBeanClass(), is(equalTo(Object.class))); + assertThat(beanDefinition.getBeanClass(), is(equalTo(Object.class))); assertThat(String.valueOf(beanDefinition.getConstructorArgumentValues() .getArgumentValue(0, RuntimeBeanReference.class).getValue()), containsString("TestPool")); @@ -165,32 +163,32 @@ public class ServerBasedExecutionBeanDefinitionBuilderTest { @Test @SuppressWarnings("unchecked") public void getGemfireFunctionOperationsBeanDefinitionBuilderWithCacheAndPool() { + FunctionExecutionConfiguration mockFunctionExecutionConfiguration = mock(FunctionExecutionConfiguration.class, "MockFunctionExecutionConfiguration"); when(mockFunctionExecutionConfiguration.getAttribute(eq("cache"))).thenReturn("TestCache"); when(mockFunctionExecutionConfiguration.getAttribute(eq("pool"))).thenReturn("TestPool"); - when(mockFunctionExecutionConfiguration.getFunctionExecutionInterface()).thenAnswer(new Answer>() { - @Override public Class answer(final InvocationOnMock invocation) throws Throwable { - return Object.class; - } - }); + when(mockFunctionExecutionConfiguration.getFunctionExecutionInterface()).thenAnswer(invocation -> Object.class); - ServerBasedExecutionBeanDefinitionBuilder builder = new ServerBasedExecutionBeanDefinitionBuilder(mockFunctionExecutionConfiguration) { - @Override protected Class getGemfireFunctionOperationsClass() { - return Object.class; - } - }; + ServerBasedExecutionBeanDefinitionBuilder builder = + new ServerBasedExecutionBeanDefinitionBuilder(mockFunctionExecutionConfiguration) { + + @Override + protected Class getGemfireFunctionOperationsClass() { + return Object.class; + } + }; expectedException.expect(IllegalStateException.class); expectedException.expectCause(is(nullValue(Throwable.class))); - expectedException.expectMessage(is(equalTo("invalid configuration for interface java.lang.Object;" + expectedException.expectMessage(is(equalTo("Invalid configuration for interface [java.lang.Object];" + " cannot specify both 'pool' and 'cache'"))); + builder.getGemfireFunctionOperationsBeanDefinitionBuilder(null); verify(mockFunctionExecutionConfiguration, times(1)).getAttribute(eq("cache")); verify(mockFunctionExecutionConfiguration, times(1)).getAttribute(eq("pool")); verify(mockFunctionExecutionConfiguration, times(1)).getFunctionExecutionInterface(); } - }