From 68eb8ec051f2be6ca41d1f0b5e8909259bb608a1 Mon Sep 17 00:00:00 2001 From: John Blum Date: Wed, 17 Jan 2018 16:04:29 -0800 Subject: [PATCH] SGF-712 - Fix incorrect server proxying behavior when registering local, client Regions using EnableCachingDefinedRegions. --- .../CachingDefinedRegionsConfiguration.java | 69 +--- .../EntityDefinedRegionsConfiguration.java | 4 +- .../AbstractAnnotationConfigSupport.java | 2 +- ...CachingDefinedRegionsIntegrationTests.java | 7 +- .../EnableCachingDefinedRegionsUnitTests.java | 347 +++++++++--------- 5 files changed, 186 insertions(+), 243 deletions(-) diff --git a/src/main/java/org/springframework/data/gemfire/config/annotation/CachingDefinedRegionsConfiguration.java b/src/main/java/org/springframework/data/gemfire/config/annotation/CachingDefinedRegionsConfiguration.java index d6e63053..ed2ce576 100644 --- a/src/main/java/org/springframework/data/gemfire/config/annotation/CachingDefinedRegionsConfiguration.java +++ b/src/main/java/org/springframework/data/gemfire/config/annotation/CachingDefinedRegionsConfiguration.java @@ -47,12 +47,8 @@ import org.apache.geode.cache.client.ClientRegionShortcut; import org.apache.geode.cache.client.Pool; import org.springframework.beans.BeanInstantiationException; import org.springframework.beans.BeansException; -import org.springframework.beans.factory.config.BeanDefinition; import org.springframework.beans.factory.config.BeanPostProcessor; import org.springframework.beans.factory.config.ConfigurableBeanFactory; -import org.springframework.beans.factory.support.BeanDefinitionBuilder; -import org.springframework.beans.factory.support.BeanDefinitionRegistry; -import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor; import org.springframework.cache.annotation.CacheEvict; import org.springframework.cache.annotation.CachePut; import org.springframework.cache.annotation.Cacheable; @@ -64,9 +60,7 @@ import org.springframework.core.annotation.AnnotationAttributes; import org.springframework.core.type.AnnotationMetadata; import org.springframework.data.gemfire.client.ClientRegionFactoryBean; import org.springframework.data.gemfire.config.annotation.support.AbstractAnnotationConfigSupport; -import org.springframework.data.gemfire.config.annotation.support.BeanDefinitionRegistryPostProcessorSupport; import org.springframework.data.gemfire.config.annotation.support.CacheTypeAwareRegionFactoryBean; -import org.springframework.data.gemfire.config.xml.GemfireConstants; import org.springframework.data.gemfire.util.CollectionUtils; import org.springframework.lang.Nullable; import org.springframework.util.StringUtils; @@ -278,55 +272,6 @@ public class CachingDefinedRegionsConfiguration extends AbstractAnnotationConfig } } - @Bean - @SuppressWarnings("all") - public BeanDefinitionRegistryPostProcessor cachingAnnotationsRegionBeanDefinitionRegistrar() { - - return new BeanDefinitionRegistryPostProcessorSupport() { - - @Override - public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException { - registerBeanDefinitions(registry); - } - }; - } - - void registerBeanDefinitions(BeanDefinitionRegistry registry) { - - for (String beanName : registry.getBeanDefinitionNames()) { - - BeanDefinition beanDefinition = registry.getBeanDefinition(beanName); - - if (isNotInfrastructureBean(beanDefinition)) { - resolveBeanClass(beanDefinition, registry).ifPresent(beanClass -> - registerRegionBeanDefinitions(getCacheNameResolver().resolveCacheNames(beanClass), registry)); - } - } - } - - private BeanDefinitionRegistry registerRegionBeanDefinitions(Set cacheNames, - BeanDefinitionRegistry registry) { - - cacheNames.forEach(cacheName -> { - - if (!registry.containsBeanDefinition(cacheName)) { - - BeanDefinitionBuilder builder = - BeanDefinitionBuilder.genericBeanDefinition(CacheTypeAwareRegionFactoryBean.class); - - builder.addPropertyReference("cache", GemfireConstants.DEFAULT_GEMFIRE_CACHE_NAME); - builder.addPropertyValue("clientRegionShortcut", resolveClientRegionShortcut()); - builder.addPropertyValue("poolName", resolvePoolName()); - builder.addPropertyValue("regionName", cacheName); - builder.addPropertyValue("serverRegionShortcut", resolveServerRegionShortcut()); - - registry.registerBeanDefinition(cacheName, builder.getBeanDefinition()); - } - }); - - return registry; - } - @Bean @SuppressWarnings("all") public BeanPostProcessor cachingAnnotationsRegionBeanRegistrar(ConfigurableBeanFactory beanFactory) { @@ -352,17 +297,21 @@ public class CachingDefinedRegionsConfiguration extends AbstractAnnotationConfig if (!beanFactory.containsBean(cacheName)) { try { - CacheTypeAwareRegionFactoryBean regionFactoryBean = - new CacheTypeAwareRegionFactoryBean<>(); + CacheTypeAwareRegionFactoryBean regionFactoryBean = new CacheTypeAwareRegionFactoryBean<>(); - GemFireCache gemfireCache = - beanFactory.getBean(GemfireConstants.DEFAULT_GEMFIRE_CACHE_NAME, GemFireCache.class); + GemFireCache gemfireCache = beanFactory.getBean(GemFireCache.class); regionFactoryBean.setCache(gemfireCache); regionFactoryBean.setClientRegionShortcut(resolveClientRegionShortcut()); - regionFactoryBean.setPoolName(resolvePoolName()); regionFactoryBean.setRegionName(cacheName); regionFactoryBean.setServerRegionShortcut(resolveServerRegionShortcut()); + + String poolName = resolvePoolName(); + + if (!ClientRegionFactoryBean.DEFAULT_POOL_NAME.equalsIgnoreCase(poolName)) { + regionFactoryBean.setPoolName(poolName); + } + regionFactoryBean.afterPropertiesSet(); Optional.ofNullable(regionFactoryBean.getObject()) diff --git a/src/main/java/org/springframework/data/gemfire/config/annotation/EntityDefinedRegionsConfiguration.java b/src/main/java/org/springframework/data/gemfire/config/annotation/EntityDefinedRegionsConfiguration.java index 1ae3d793..a30de0cb 100644 --- a/src/main/java/org/springframework/data/gemfire/config/annotation/EntityDefinedRegionsConfiguration.java +++ b/src/main/java/org/springframework/data/gemfire/config/annotation/EntityDefinedRegionsConfiguration.java @@ -626,8 +626,8 @@ public class EntityDefinedRegionsConfiguration extends AbstractAnnotationConfigS private String poolName; protected RegionBeanDefinitionMetadata(GemfirePersistentEntity persistentEntity) { - this.persistentEntity = Optional.ofNullable(persistentEntity) - .orElseThrow(() -> newIllegalArgumentException("GemfirePeristentEntity is required")); + Assert.notNull(persistentEntity, "GemfirePersistentEntity is required"); + this.persistentEntity = persistentEntity; } protected boolean isStrict() { diff --git a/src/main/java/org/springframework/data/gemfire/config/annotation/support/AbstractAnnotationConfigSupport.java b/src/main/java/org/springframework/data/gemfire/config/annotation/support/AbstractAnnotationConfigSupport.java index 59b52715..d2c2cb12 100644 --- a/src/main/java/org/springframework/data/gemfire/config/annotation/support/AbstractAnnotationConfigSupport.java +++ b/src/main/java/org/springframework/data/gemfire/config/annotation/support/AbstractAnnotationConfigSupport.java @@ -1077,7 +1077,7 @@ public abstract class AbstractAnnotationConfigSupport try { return typeResolver.resolve(); } - catch (ClassNotFoundException cause) { + catch (ClassNotFoundException | NoClassDefFoundError cause) { return null; } } diff --git a/src/test/java/org/springframework/data/gemfire/config/annotation/EnableCachingDefinedRegionsIntegrationTests.java b/src/test/java/org/springframework/data/gemfire/config/annotation/EnableCachingDefinedRegionsIntegrationTests.java index 6c3d6e3e..26078750 100644 --- a/src/test/java/org/springframework/data/gemfire/config/annotation/EnableCachingDefinedRegionsIntegrationTests.java +++ b/src/test/java/org/springframework/data/gemfire/config/annotation/EnableCachingDefinedRegionsIntegrationTests.java @@ -25,11 +25,11 @@ import javax.cache.annotation.CacheRemoveAll; import javax.cache.annotation.CacheResult; import org.apache.geode.cache.GemFireCache; +import org.apache.geode.cache.client.ClientRegionShortcut; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.cache.annotation.CachePut; import org.springframework.cache.annotation.Cacheable; import org.springframework.context.ApplicationContext; @@ -107,8 +107,8 @@ public class EnableCachingDefinedRegionsIntegrationTests { assertThat(springEchoService.isCacheMiss()).isFalse(); } - @PeerCacheApplication(name = "EnableCachingDefinedRegionsIntegrationTests", logLevel = "warning") - @EnableCachingDefinedRegions + @ClientCacheApplication(name = "EnableCachingDefinedRegionsIntegrationTests", logLevel = "error") + @EnableCachingDefinedRegions(clientRegionShortcut = ClientRegionShortcut.LOCAL) static class TestConfiguration { @Bean @@ -117,7 +117,6 @@ public class EnableCachingDefinedRegionsIntegrationTests { } @Bean - @Qualifier("Spring") SpringCacheableEchoService springEchoService() { return new SpringCacheableEchoService(); } diff --git a/src/test/java/org/springframework/data/gemfire/config/annotation/EnableCachingDefinedRegionsUnitTests.java b/src/test/java/org/springframework/data/gemfire/config/annotation/EnableCachingDefinedRegionsUnitTests.java index 4ea63f0b..29df9d66 100644 --- a/src/test/java/org/springframework/data/gemfire/config/annotation/EnableCachingDefinedRegionsUnitTests.java +++ b/src/test/java/org/springframework/data/gemfire/config/annotation/EnableCachingDefinedRegionsUnitTests.java @@ -22,14 +22,13 @@ import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.doAnswer; 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 static org.springframework.data.gemfire.util.CollectionUtils.asSet; -import static org.springframework.data.gemfire.util.RuntimeExceptionFactory.newRuntimeException; import java.util.Arrays; +import java.util.HashSet; import java.util.Map; import java.util.Set; @@ -38,19 +37,21 @@ import javax.cache.annotation.CacheRemove; import javax.cache.annotation.CacheRemoveAll; import javax.cache.annotation.CacheResult; +import org.apache.geode.cache.GemFireCache; +import org.apache.geode.cache.Region; import org.apache.geode.cache.RegionShortcut; import org.apache.geode.cache.client.ClientRegionShortcut; import org.junit.Before; import org.junit.Test; -import org.springframework.beans.factory.config.BeanDefinition; -import org.springframework.beans.factory.support.AbstractBeanDefinition; -import org.springframework.beans.factory.support.BeanDefinitionRegistry; +import org.springframework.beans.factory.config.BeanPostProcessor; +import org.springframework.beans.factory.config.ConfigurableBeanFactory; import org.springframework.cache.annotation.CacheEvict; import org.springframework.cache.annotation.CachePut; import org.springframework.cache.annotation.Cacheable; import org.springframework.cache.annotation.Caching; import org.springframework.core.type.AnnotationMetadata; import org.springframework.data.gemfire.client.ClientRegionFactoryBean; +import org.springframework.data.gemfire.test.mock.MockGemFireObjectsSupport; import org.springframework.data.gemfire.test.support.MapBuilder; import org.springframework.stereotype.Service; @@ -77,43 +78,7 @@ public class EnableCachingDefinedRegionsUnitTests { @Before public void setup() { this.configuration = new CachingDefinedRegionsConfiguration(); - } - - @SuppressWarnings("unchecked") - private BeanDefinition mockBeanDefinition(Class beanClass) { - - try { - - AbstractBeanDefinition mockBeanDefinition = mock(AbstractBeanDefinition.class, beanClass.getSimpleName()); - - when(mockBeanDefinition.getBeanClassName()).thenReturn(beanClass.getName()); - when(mockBeanDefinition.resolveBeanClass(any(ClassLoader.class))).thenReturn((Class) beanClass); - when(mockBeanDefinition.getRole()).thenReturn(BeanDefinition.ROLE_APPLICATION); - - return mockBeanDefinition; - } - catch (ClassNotFoundException cause) { - throw newRuntimeException(cause, "Creating a mock for class [%s] failed", beanClass.getName()); - } - } - - private BeanDefinitionRegistry mockBeanDefinitionRegistry(Map registeredBeanDefinitions) { - - BeanDefinitionRegistry mockBeanDefinitionRegistry = mock(BeanDefinitionRegistry.class); - - when(mockBeanDefinitionRegistry.getBeanDefinitionNames()) - .thenReturn(registeredBeanDefinitions.keySet().toArray(new String[registeredBeanDefinitions.size()])); - - when(mockBeanDefinitionRegistry.getBeanDefinition(anyString())) - .thenAnswer(invocation -> registeredBeanDefinitions.get(invocation.getArgument(0))); - - when(mockBeanDefinitionRegistry.containsBeanDefinition(anyString())) - .thenAnswer(invocation -> registeredBeanDefinitions.containsKey(invocation.getArgument(0))); - - doAnswer(invocation -> registeredBeanDefinitions.put(invocation.getArgument(0), invocation.getArgument(1))) - .when(mockBeanDefinitionRegistry).registerBeanDefinition(anyString(), any(BeanDefinition.class)); - - return mockBeanDefinitionRegistry; + MockGemFireObjectsSupport.destroy(); } @Test @@ -222,100 +187,116 @@ public class EnableCachingDefinedRegionsUnitTests { @Test public void cacheableServiceOneRegistersRegionsOneAndTwo() { - Map registeredBeanDefinitions = MapBuilder.newMapBuilder() - .put("cacheableServiceOne", mockBeanDefinition(CacheableServiceOne.class)) - .build(); + ConfigurableBeanFactory mockBeanFactory = mock(ConfigurableBeanFactory.class); - BeanDefinitionRegistry mockBeanDefinitionRegistry = mockBeanDefinitionRegistry(registeredBeanDefinitions); + GemFireCache mockGemFireCache = MockGemFireObjectsSupport.mockClientCache(); - this.configuration.registerBeanDefinitions(mockBeanDefinitionRegistry); + when(mockBeanFactory.containsBean(anyString())).thenReturn(false); + when(mockBeanFactory.getBean(eq(GemFireCache.class))).thenReturn(mockGemFireCache); - verify(mockBeanDefinitionRegistry, times(1)).getBeanDefinitionNames(); + BeanPostProcessor cachingAnnotationsRegionBeanRegistrar = + this.configuration.cachingAnnotationsRegionBeanRegistrar(mockBeanFactory); - verify(mockBeanDefinitionRegistry, times(1)) - .getBeanDefinition(eq("cacheableServiceOne")); - - verify(mockBeanDefinitionRegistry, times(2)) - .registerBeanDefinition(anyString(), any(BeanDefinition.class)); + cachingAnnotationsRegionBeanRegistrar + .postProcessBeforeInitialization(new CacheableServiceOne(), "cacheableServiceOne"); Arrays.asList("RegionOne", "RegionTwo").forEach(beanName -> { - verify(mockBeanDefinitionRegistry, times(1)).containsBeanDefinition(eq(beanName)); - verify(mockBeanDefinitionRegistry, times(1)) - .registerBeanDefinition(eq(beanName), any(BeanDefinition.class)); + verify(mockBeanFactory, times(1)).containsBean(eq(beanName)); + verify(mockBeanFactory, times(2)).getBean(eq(GemFireCache.class)); + verify(mockBeanFactory, times(1)) + .registerSingleton(eq(beanName), any(Region.class)); }); } @Test public void cacheableServiceTwoRegistersRegionsTwoThreeFourFiveAndSix() { - Map registeredBeanDefinitions = MapBuilder.newMapBuilder() - .put("cacheableServiceTwo", mockBeanDefinition(CacheableServiceTwo.class)) - .build(); + ConfigurableBeanFactory mockBeanFactory = mock(ConfigurableBeanFactory.class); - BeanDefinitionRegistry mockBeanDefinitionRegistry = mockBeanDefinitionRegistry(registeredBeanDefinitions); + GemFireCache mockGemFireCache = MockGemFireObjectsSupport.mockClientCache(); - this.configuration.registerBeanDefinitions(mockBeanDefinitionRegistry); + Set registeredBeanNames = new HashSet<>(); - Set registeredRegionBeanNames = - asSet("RegionTwo", "RegionThree", "RegionFour", "RegionFive", "RegionSix"); + when(mockBeanFactory.containsBean(anyString())).thenAnswer(invocation -> + registeredBeanNames.contains(invocation.getArgument(0))); - verify(mockBeanDefinitionRegistry, times(1)).getBeanDefinitionNames(); + when(mockBeanFactory.getBean(eq(GemFireCache.class))).thenReturn(mockGemFireCache); - verify(mockBeanDefinitionRegistry, times(1)) - .getBeanDefinition(eq("cacheableServiceTwo")); + doAnswer(invocation -> registeredBeanNames.add(invocation.getArgument(0))).when(mockBeanFactory) + .registerSingleton(anyString(), any()); - verify(mockBeanDefinitionRegistry, times(registeredRegionBeanNames.size())) - .registerBeanDefinition(anyString(), any(BeanDefinition.class)); + BeanPostProcessor cachingAnnotationsRegionBeanRegistrar = + this.configuration.cachingAnnotationsRegionBeanRegistrar(mockBeanFactory); - registeredRegionBeanNames.forEach(beanName -> { - verify(mockBeanDefinitionRegistry, times(1)).containsBeanDefinition(eq(beanName)); - verify(mockBeanDefinitionRegistry, times(1)) - .registerBeanDefinition(eq(beanName), any(BeanDefinition.class)); + cachingAnnotationsRegionBeanRegistrar + .postProcessBeforeInitialization(new CacheableServiceTwo(), "cacheableServiceTwo"); + + Arrays.asList("RegionTwo", "RegionThree", "RegionFour", "RegionFive", "RegionSix").forEach(beanName -> { + verify(mockBeanFactory, times(1)).containsBean(eq(beanName)); + verify(mockBeanFactory, times(5)).getBean(eq(GemFireCache.class)); + verify(mockBeanFactory, times(1)) + .registerSingleton(eq(beanName), any(Region.class)); }); - } @Test public void cacheableServiceThreeRegistersSeventeenRegionBeans() { - Map registeredBeanDefinitions = MapBuilder.newMapBuilder() - .put("cacheableServiceThree", mockBeanDefinition(CacheableServiceThree.class)) - .build(); + ConfigurableBeanFactory mockBeanFactory = mock(ConfigurableBeanFactory.class); - BeanDefinitionRegistry mockBeanDefinitionRegistry = mockBeanDefinitionRegistry(registeredBeanDefinitions); + GemFireCache mockGemFireCache = MockGemFireObjectsSupport.mockClientCache(); - this.configuration.registerBeanDefinitions(mockBeanDefinitionRegistry); + Set registeredBeanNames = new HashSet<>(); + + when(mockBeanFactory.containsBean(anyString())).thenAnswer(invocation -> + registeredBeanNames.contains(invocation.getArgument(0))); + + when(mockBeanFactory.getBean(eq(GemFireCache.class))).thenReturn(mockGemFireCache); + + doAnswer(invocation -> registeredBeanNames.add(invocation.getArgument(0))).when(mockBeanFactory) + .registerSingleton(anyString(), any()); + + BeanPostProcessor cachingAnnotationsRegionBeanRegistrar = + this.configuration.cachingAnnotationsRegionBeanRegistrar(mockBeanFactory); + + cachingAnnotationsRegionBeanRegistrar + .postProcessBeforeInitialization(new CacheableServiceThree(), "cacheableServiceThree"); Set registeredRegionBeanNames = asSet("RegionSix", "RegionSeven", "RegionEight", "RegionNine", "RegionTen", "RegionEleven", "RegionTwelve", "RegionThirteen", "RegionFourteen", "RegionFifteen", "RegionSixteen", "RegionSeventeen", "RegionEighteen", "RegionNineteen", "RegionTwenty", "RegionTwentyOne", "RegionTwentyFive"); - verify(mockBeanDefinitionRegistry, times(1)).getBeanDefinitionNames(); - - verify(mockBeanDefinitionRegistry, times(1)) - .getBeanDefinition(eq("cacheableServiceThree")); - - verify(mockBeanDefinitionRegistry, times(registeredRegionBeanNames.size())) - .registerBeanDefinition(anyString(), any(BeanDefinition.class)); - registeredRegionBeanNames.forEach(beanName -> { - verify(mockBeanDefinitionRegistry, times(1)).containsBeanDefinition(eq(beanName)); - verify(mockBeanDefinitionRegistry, times(1)) - .registerBeanDefinition(eq(beanName), any(BeanDefinition.class)); + verify(mockBeanFactory, times(1)).containsBean(eq(beanName)); + verify(mockBeanFactory, times(registeredBeanNames.size())).getBean(eq(GemFireCache.class)); + verify(mockBeanFactory, times(1)) + .registerSingleton(eq(beanName), any(Region.class)); }); } @Test public void cacheableServiceFourRegistersNineteenRegionBeans() { - Map registeredBeanDefinitions = MapBuilder.newMapBuilder() - .put("cacheableServiceFour", mockBeanDefinition(CacheableServiceFour.class)) - .build(); + ConfigurableBeanFactory mockBeanFactory = mock(ConfigurableBeanFactory.class); - BeanDefinitionRegistry mockBeanDefinitionRegistry = mockBeanDefinitionRegistry(registeredBeanDefinitions); + GemFireCache mockGemFireCache = MockGemFireObjectsSupport.mockClientCache(); - this.configuration.registerBeanDefinitions(mockBeanDefinitionRegistry); + Set registeredBeanNames = new HashSet<>(); + + when(mockBeanFactory.containsBean(anyString())).thenAnswer(invocation -> + registeredBeanNames.contains(invocation.getArgument(0))); + + when(mockBeanFactory.getBean(eq(GemFireCache.class))).thenReturn(mockGemFireCache); + + doAnswer(invocation -> registeredBeanNames.add(invocation.getArgument(0))).when(mockBeanFactory) + .registerSingleton(anyString(), any()); + + BeanPostProcessor cachingAnnotationsRegionBeanRegistrar = + this.configuration.cachingAnnotationsRegionBeanRegistrar(mockBeanFactory); + + cachingAnnotationsRegionBeanRegistrar + .postProcessBeforeInitialization(new CacheableServiceFour(), "cacheableServiceFour"); Set registeredRegionBeanNames = asSet("RegionSix", "RegionSeven", "RegionEight", "RegionNine", "RegionTen", "RegionEleven", @@ -323,36 +304,42 @@ public class EnableCachingDefinedRegionsUnitTests { "RegionEighteen", "RegionNineteen", "RegionTwenty", "RegionTwentyOne", "RegionTwentyTwo", "RegionTwentyThree", "RegionTwentyFour"); - verify(mockBeanDefinitionRegistry, times(1)).getBeanDefinitionNames(); - - verify(mockBeanDefinitionRegistry, times(1)) - .getBeanDefinition(eq("cacheableServiceFour")); - - verify(mockBeanDefinitionRegistry, never()) - .registerBeanDefinition(eq("RegionTwentyFive"), any(BeanDefinition.class)); - - verify(mockBeanDefinitionRegistry, times(registeredRegionBeanNames.size())) - .registerBeanDefinition(anyString(), any(BeanDefinition.class)); - registeredRegionBeanNames.forEach(beanName -> { - verify(mockBeanDefinitionRegistry, times(1)).containsBeanDefinition(eq(beanName)); - verify(mockBeanDefinitionRegistry, times(1)) - .registerBeanDefinition(eq(beanName), any(BeanDefinition.class)); + verify(mockBeanFactory, times(1)).containsBean(eq(beanName)); + verify(mockBeanFactory, times(registeredBeanNames.size())).getBean(eq(GemFireCache.class)); + verify(mockBeanFactory, times(1)) + .registerSingleton(eq(beanName), any(Region.class)); }); } @Test public void cacheableServiceOneTwoAndThreeRegistersTwentyTwoRegionBeans() { - Map registeredBeanDefinitions = MapBuilder.newMapBuilder() - .put("cacheableServiceOne", mockBeanDefinition(CacheableServiceOne.class)) - .put("cacheableServiceTwo", mockBeanDefinition(CacheableServiceTwo.class)) - .put("cacheableServiceThree", mockBeanDefinition(CacheableServiceThree.class)) - .build(); + ConfigurableBeanFactory mockBeanFactory = mock(ConfigurableBeanFactory.class); - BeanDefinitionRegistry mockBeanDefinitionRegistry = mockBeanDefinitionRegistry(registeredBeanDefinitions); + GemFireCache mockGemFireCache = MockGemFireObjectsSupport.mockClientCache(); - this.configuration.registerBeanDefinitions(mockBeanDefinitionRegistry); + Set registeredBeanNames = new HashSet<>(); + + when(mockBeanFactory.containsBean(anyString())).thenAnswer(invocation -> + registeredBeanNames.contains(invocation.getArgument(0))); + + when(mockBeanFactory.getBean(eq(GemFireCache.class))).thenReturn(mockGemFireCache); + + doAnswer(invocation -> registeredBeanNames.add(invocation.getArgument(0))).when(mockBeanFactory) + .registerSingleton(anyString(), any()); + + BeanPostProcessor cachingAnnotationsRegionBeanRegistrar = + this.configuration.cachingAnnotationsRegionBeanRegistrar(mockBeanFactory); + + cachingAnnotationsRegionBeanRegistrar + .postProcessBeforeInitialization(new CacheableServiceOne(), "cacheableServiceOne"); + + cachingAnnotationsRegionBeanRegistrar + .postProcessBeforeInitialization(new CacheableServiceTwo(), "cacheableServiceTwo"); + + cachingAnnotationsRegionBeanRegistrar + .postProcessBeforeInitialization(new CacheableServiceThree(), "cacheableServiceThree"); Set registeredRegionBeanNames = asSet("RegionOne", "RegionTwo", "RegionThree", "RegionFour", "RegionFive", "RegionSix", @@ -360,111 +347,118 @@ public class EnableCachingDefinedRegionsUnitTests { "RegionThirteen", "RegionFourteen", "RegionFifteen", "RegionSixteen", "RegionSeventeen", "RegionEighteen", "RegionNineteen", "RegionTwenty", "RegionTwentyOne", "RegionTwentyFive"); - verify(mockBeanDefinitionRegistry, times(1)).getBeanDefinitionNames(); - - Arrays.asList("cacheableServiceOne", "cacheableServiceTwo", "cacheableServiceThree").forEach(beanName -> - verify(mockBeanDefinitionRegistry, times(1)).getBeanDefinition(eq(beanName))); - - verify(mockBeanDefinitionRegistry, times(registeredRegionBeanNames.size())) - .registerBeanDefinition(anyString(), any(BeanDefinition.class)); - registeredRegionBeanNames.forEach(beanName -> { - int wantedNumberOfInvocations = "RegionSix".equals(beanName) || "RegionTwo".equals(beanName) ? 2 : 1; + int wantedNumberOfInvocations = asSet("RegionTwo", "RegionSix").contains(beanName) ? 2 : 1; - verify(mockBeanDefinitionRegistry, times(wantedNumberOfInvocations)).containsBeanDefinition(eq(beanName)); - - verify(mockBeanDefinitionRegistry, times(1)) - .registerBeanDefinition(eq(beanName), any(BeanDefinition.class)); + verify(mockBeanFactory, times(wantedNumberOfInvocations)).containsBean(eq(beanName)); + verify(mockBeanFactory, times(registeredBeanNames.size())).getBean(eq(GemFireCache.class)); + verify(mockBeanFactory, times(1)) + .registerSingleton(eq(beanName), any(Region.class)); }); } @Test public void cacheableServiceFiveRegistersRegionOneTwoThreeFourFiveSixAndSeven() { - Map registeredBeanDefinitions = MapBuilder.newMapBuilder() - .put("cacheableServiceFive", mockBeanDefinition(CacheableServiceFive.class)) - .build(); + ConfigurableBeanFactory mockBeanFactory = mock(ConfigurableBeanFactory.class); - BeanDefinitionRegistry mockBeanDefinitionRegistry = mockBeanDefinitionRegistry(registeredBeanDefinitions); + GemFireCache mockGemFireCache = MockGemFireObjectsSupport.mockClientCache(); - this.configuration.registerBeanDefinitions(mockBeanDefinitionRegistry); + Set registeredBeanNames = new HashSet<>(); + + when(mockBeanFactory.containsBean(anyString())).thenAnswer(invocation -> + registeredBeanNames.contains(invocation.getArgument(0))); + + when(mockBeanFactory.getBean(eq(GemFireCache.class))).thenReturn(mockGemFireCache); + + doAnswer(invocation -> registeredBeanNames.add(invocation.getArgument(0))).when(mockBeanFactory) + .registerSingleton(anyString(), any()); + + BeanPostProcessor cachingAnnotationsRegionBeanRegistrar = + this.configuration.cachingAnnotationsRegionBeanRegistrar(mockBeanFactory); + + cachingAnnotationsRegionBeanRegistrar + .postProcessBeforeInitialization(new CacheableServiceFive(), "cacheableServiceFive"); Set registeredRegionBeanNames = asSet("RegionOne", "RegionTwo", "RegionThree", "RegionFour", "RegionFive", "RegionSix", "RegionSeven"); - verify(mockBeanDefinitionRegistry, times(1)).getBeanDefinitionNames(); - - verify(mockBeanDefinitionRegistry, times(1)) - .getBeanDefinition(eq("cacheableServiceFive")); - - verify(mockBeanDefinitionRegistry, times(registeredRegionBeanNames.size())) - .registerBeanDefinition(anyString(), any(BeanDefinition.class)); - registeredRegionBeanNames.forEach(beanName -> { - verify(mockBeanDefinitionRegistry, times(1)).containsBeanDefinition(eq(beanName)); - verify(mockBeanDefinitionRegistry, times(1)) - .registerBeanDefinition(eq(beanName), any(BeanDefinition.class)); + verify(mockBeanFactory, times(1)).containsBean(eq(beanName)); + verify(mockBeanFactory, times(registeredBeanNames.size())).getBean(eq(GemFireCache.class)); + verify(mockBeanFactory, times(1)) + .registerSingleton(eq(beanName), any(Region.class)); }); } @Test public void cacheableServiceSixRegistersRegionOneTwoThreeFourAndFive() { - Map registeredBeanDefinitions = MapBuilder.newMapBuilder() - .put("cacheableServiceSix", mockBeanDefinition(CacheableServiceSix.class)) - .build(); + ConfigurableBeanFactory mockBeanFactory = mock(ConfigurableBeanFactory.class); - BeanDefinitionRegistry mockBeanDefinitionRegistry = mockBeanDefinitionRegistry(registeredBeanDefinitions); + GemFireCache mockGemFireCache = MockGemFireObjectsSupport.mockClientCache(); - this.configuration.registerBeanDefinitions(mockBeanDefinitionRegistry); + Set registeredBeanNames = new HashSet<>(); + + when(mockBeanFactory.containsBean(anyString())).thenAnswer(invocation -> + registeredBeanNames.contains(invocation.getArgument(0))); + + when(mockBeanFactory.getBean(eq(GemFireCache.class))).thenReturn(mockGemFireCache); + + doAnswer(invocation -> registeredBeanNames.add(invocation.getArgument(0))).when(mockBeanFactory) + .registerSingleton(anyString(), any()); + + BeanPostProcessor cachingAnnotationsRegionBeanRegistrar = + this.configuration.cachingAnnotationsRegionBeanRegistrar(mockBeanFactory); + + cachingAnnotationsRegionBeanRegistrar + .postProcessBeforeInitialization(new CacheableServiceSix(), "cacheableServiceSix"); Set registeredRegionBeanNames = asSet("RegionOne", "RegionTwo", "RegionThree", "RegionFour", "RegionFive"); - verify(mockBeanDefinitionRegistry, times(1)).getBeanDefinitionNames(); - - verify(mockBeanDefinitionRegistry, times(1)) - .getBeanDefinition(eq("cacheableServiceSix")); - - verify(mockBeanDefinitionRegistry, times(registeredRegionBeanNames.size())) - .registerBeanDefinition(anyString(), any(BeanDefinition.class)); - registeredRegionBeanNames.forEach(beanName -> { - verify(mockBeanDefinitionRegistry, times(1)).containsBeanDefinition(eq(beanName)); - verify(mockBeanDefinitionRegistry, times(1)) - .registerBeanDefinition(eq(beanName), any(BeanDefinition.class)); + verify(mockBeanFactory, times(1)).containsBean(eq(beanName)); + verify(mockBeanFactory, times(registeredBeanNames.size())).getBean(eq(GemFireCache.class)); + verify(mockBeanFactory, times(1)) + .registerSingleton(eq(beanName), any(Region.class)); }); } @Test public void cacheableServiceSevenRegistersRegionOneThroughEleven() { - Map registeredBeanDefinitions = MapBuilder.newMapBuilder() - .put("cacheableServiceSeven", mockBeanDefinition(CacheableServiceSeven.class)) - .build(); + ConfigurableBeanFactory mockBeanFactory = mock(ConfigurableBeanFactory.class); - BeanDefinitionRegistry mockBeanDefinitionRegistry = mockBeanDefinitionRegistry(registeredBeanDefinitions); + GemFireCache mockGemFireCache = MockGemFireObjectsSupport.mockClientCache(); - this.configuration.registerBeanDefinitions(mockBeanDefinitionRegistry); + Set registeredBeanNames = new HashSet<>(); + + when(mockBeanFactory.containsBean(anyString())).thenAnswer(invocation -> + registeredBeanNames.contains(invocation.getArgument(0))); + + when(mockBeanFactory.getBean(eq(GemFireCache.class))).thenReturn(mockGemFireCache); + + doAnswer(invocation -> registeredBeanNames.add(invocation.getArgument(0))).when(mockBeanFactory) + .registerSingleton(anyString(), any()); + + BeanPostProcessor cachingAnnotationsRegionBeanRegistrar = + this.configuration.cachingAnnotationsRegionBeanRegistrar(mockBeanFactory); + + cachingAnnotationsRegionBeanRegistrar + .postProcessBeforeInitialization(new CacheableServiceSeven(), "cacheableServiceSeven"); Set registeredRegionBeanNames = asSet("RegionOne", "RegionTwo", "RegionThree", "RegionFour", "RegionFive", "RegionSix", "RegionSeven", "RegionEight", "RegionNine", "RegionTen", "RegionEleven"); - verify(mockBeanDefinitionRegistry, times(1)).getBeanDefinitionNames(); - - verify(mockBeanDefinitionRegistry, times(1)) - .getBeanDefinition(eq("cacheableServiceSeven")); - - verify(mockBeanDefinitionRegistry, times(registeredRegionBeanNames.size())) - .registerBeanDefinition(anyString(), any(BeanDefinition.class)); - registeredRegionBeanNames.forEach(beanName -> { - verify(mockBeanDefinitionRegistry, times(1)).containsBeanDefinition(eq(beanName)); - verify(mockBeanDefinitionRegistry, times(1)) - .registerBeanDefinition(eq(beanName), any(BeanDefinition.class)); + verify(mockBeanFactory, times(1)).containsBean(eq(beanName)); + verify(mockBeanFactory, times(registeredBeanNames.size())).getBean(eq(GemFireCache.class)); + verify(mockBeanFactory, times(1)) + .registerSingleton(eq(beanName), any(Region.class)); }); } @@ -580,6 +574,7 @@ public class EnableCachingDefinedRegionsUnitTests { put = @CachePut("RegionTwo") ) @CacheDefaults(cacheName = "RegionOne") + @SuppressWarnings("unused") static class CacheableServiceSeven extends CacheableServiceSix { @CachePut("RegionTen")