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

Add 'destroyOnEvent' configuration annotation attribute.

Browse Source 
The 'destoryOnEvent' EnableGemFireMockObjects annotation attribute configures specific Spring ApplicationEvent types (Class) that will trigger the destruction of all GemFire/Geode Mock Objects.

Add bean definition and declaration for the DestroyGemFireMockObjectsApplicationListener.

Add Unit Tests for the GemFireMockObjectsConfiguration class.

Resolves gh-20.
This commit is contained in:
John Blum
2020-05-21 21:32:35 -07:00
parent 53893bd49f
commit af9237eeb1
3 changed files with 39 additions and 87 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
spring-data-geode-test/src/main/java/org/springframework/data/gemfire/tests/mock/annotation/EnableGemFireMockObjects.java
View File

@@ -24,7 +24,9 @@ import java.lang.annotation.Target;
import org.apache.geode.cache.GemFireCache;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.annotation.Import;
import org.springframework.test.context.event.AfterTestClassEvent;
/**
* The {@link EnableGemFireMockObjects} annotation enables mocking of GemFire Objects in Unit Tests.
@@ -47,16 +49,15 @@ import org.springframework.context.annotation.Import;
public @interface EnableGemFireMockObjects {
/**
* Configures whether the {@link org.springframework.context.event.ContextClosedEvent} Spring
* {@link org.springframework.context.ApplicationEvent} listener and handler for GemFire/Geode
* {@link Object Mock Objects} is suppressed from taking action.
* Configures the {@link Class type} of {@link ApplicationEvent ApplicationEvents} that will trigger all currently
* allocated GemFire/Geode {@link Object Mock Objects} to be destroyed.
*
* Defaults to {@literal false}.
*
* @return a boolean value indicating whether the {@link org.springframework.context.event.ContextClosedEvent}
* listener and handler for GemFire/Geode {@link Object Mock Objects} is suppressed from taking action.
* @return an array of {@link ApplicationEvent} {@link Class types} that will trigger all currently allocated
* GemFire/Geode {@link Object Mock Objects} to be destroyed.
* @see org.springframework.context.ApplicationEvent
* @see java.lang.Class
*/
boolean suppressOnContextClosedEventHandler() default false;
Class<? extends ApplicationEvent>[] destroyOnEvent() default { AfterTestClassEvent.class };
/**
* Configures whether the mock {@link GemFireCache} created for Unit Testing is a Singleton.

66
spring-data-geode-test/src/main/java/org/springframework/data/gemfire/tests/mock/annotation/GemFireMockObjectsConfiguration.java
View File

@@ -19,16 +19,16 @@ import java.lang.annotation.Annotation;
import java.util.Optional;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportAware;
import org.springframework.context.event.ContextClosedEvent;
import org.springframework.context.event.EventListener;
import org.springframework.core.annotation.AnnotationAttributes;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.data.gemfire.tests.mock.GemFireMockObjectsSupport;
import org.springframework.data.gemfire.tests.mock.config.GemFireMockObjectsBeanPostProcessor;
import org.springframework.data.gemfire.tests.mock.beans.factory.config.GemFireMockObjectsBeanPostProcessor;
import org.springframework.data.gemfire.tests.mock.context.event.DestroyGemFireMockObjectsApplicationListener;
import org.springframework.lang.NonNull;
/**
* The {@link GemFireMockObjectsConfiguration} class is a Spring {@link Configuration @Configuration} class
@@ -46,63 +46,61 @@ import org.springframework.data.gemfire.tests.mock.config.GemFireMockObjectsBean
* @see org.springframework.core.annotation.AnnotationAttributes
* @see org.springframework.core.type.AnnotationMetadata
* @see org.springframework.data.gemfire.tests.mock.GemFireMockObjectsSupport
* @see org.springframework.data.gemfire.tests.mock.config.GemFireMockObjectsBeanPostProcessor
* @see GemFireMockObjectsBeanPostProcessor
* @since 0.0.1
*/
@Configuration
@SuppressWarnings("unused")
public class GemFireMockObjectsConfiguration implements ApplicationListener<ContextClosedEvent>, ImportAware {
private boolean suppressContextClosedEventHandler = false;
public class GemFireMockObjectsConfiguration implements ImportAware {
private boolean useSingletonCache = false;
@Override @SuppressWarnings("all")
public void setImportMetadata(AnnotationMetadata importingClassMetadata) {
@SuppressWarnings("unchecked")
private Class<? extends ApplicationEvent>[] destroyEventTypes = new Class[0];
@Override
@SuppressWarnings("unchecked")
public void setImportMetadata(@NonNull AnnotationMetadata importingClassMetadata) {
Optional.of(importingClassMetadata)
.filter(this::isAnnotationPresent)
.map(this::getAnnotationAttributes)
.ifPresent(enableGemFireMockObjectsAttributes -> {
this.suppressContextClosedEventHandler =
enableGemFireMockObjectsAttributes.getBoolean("suppressOnContextClosedEventHandler");
this.destroyEventTypes = (Class<? extends ApplicationEvent>[])
enableGemFireMockObjectsAttributes.getClassArray("destroyOnEvent");
this.useSingletonCache =
enableGemFireMockObjectsAttributes.getBoolean("useSingletonCache");
});
}
private Class<? extends Annotation> getAnnotationType() {
private @NonNull Class<? extends Annotation> getAnnotationType() {
return EnableGemFireMockObjects.class;
}
private boolean isAnnotationPresent(AnnotationMetadata importingClassMetadata) {
private boolean isAnnotationPresent(@NonNull AnnotationMetadata importingClassMetadata) {
return isAnnotationPresent(importingClassMetadata, getAnnotationType());
}
private boolean isAnnotationPresent(AnnotationMetadata importingClassMetadata,
Class<? extends Annotation> annotationType) {
private boolean isAnnotationPresent(@NonNull AnnotationMetadata importingClassMetadata,
@NonNull Class<? extends Annotation> annotationType) {
return importingClassMetadata.hasAnnotation(annotationType.getName());
}
private AnnotationAttributes getAnnotationAttributes(AnnotationMetadata importingClassMetadata) {
private AnnotationAttributes getAnnotationAttributes(@NonNull AnnotationMetadata importingClassMetadata) {
return getAnnotationAttributes(importingClassMetadata, getAnnotationType());
}
private AnnotationAttributes getAnnotationAttributes(AnnotationMetadata importingClassMetadata,
Class<? extends Annotation> annotationType) {
private AnnotationAttributes getAnnotationAttributes(@NonNull AnnotationMetadata importingClassMetadata,
@NonNull Class<? extends Annotation> annotationType) {
return AnnotationAttributes.fromMap(importingClassMetadata.getAnnotationAttributes(annotationType.getName()));
}
protected boolean isNotSuppressOnContextClosedEvent() {
return !isSuppressOnContextClosedEvent();
}
protected boolean isSuppressOnContextClosedEvent() {
return this.suppressContextClosedEventHandler;
protected Class<? extends ApplicationEvent>[] getConfiguredDestroyEventTypes() {
return this.destroyEventTypes;
}
protected boolean isUseSingletonCacheConfigured() {
@@ -114,20 +112,8 @@ public class GemFireMockObjectsConfiguration implements ApplicationListener<Cont
return GemFireMockObjectsBeanPostProcessor.newInstance(isUseSingletonCacheConfigured());
}
@EventListener
public void releaseMockObjectResources(ContextClosedEvent event) {
if (isNotSuppressOnContextClosedEvent()) {
destroyGemFireMockObjects();
}
}
@Override @SuppressWarnings("all")
public void onApplicationEvent(ContextClosedEvent event) {
releaseMockObjectResources(event);
}
void destroyGemFireMockObjects() {
GemFireMockObjectsSupport.destroy();
@Bean
public ApplicationListener<ApplicationEvent> destroyGemFireMockObjectsApplicationListener() {
return DestroyGemFireMockObjectsApplicationListener.newInstance(getConfiguredDestroyEventTypes());
}
}

43
spring-data-geode-test/src/test/java/org/springframework/data/gemfire/tests/mock/annotation/GemFireMockObjectsConfigurationUnitTests.java
View File

@@ -17,11 +17,8 @@ package org.springframework.data.gemfire.tests.mock.annotation;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
@@ -47,16 +44,16 @@ import org.springframework.core.type.AnnotationMetadata;
public class GemFireMockObjectsConfigurationUnitTests {
@Test
public void setImportMetadataConfiguresSingletonCacheAndSuppressContextClosedEvents() {
public void setImportMetadataConfiguresSingletonCacheAndDestroysMockObjectsOnConfiguredEvents() {
GemFireMockObjectsConfiguration configuration = new GemFireMockObjectsConfiguration();
assertThat(configuration.isSuppressOnContextClosedEvent()).isFalse();
assertThat(configuration.getConfiguredDestroyEventTypes()).isEmpty();
assertThat(configuration.isUseSingletonCacheConfigured()).isFalse();
Map<String, Object> enableGemFireMockObjectsAttributes = new HashMap<>();
enableGemFireMockObjectsAttributes.put("suppressOnContextClosedEventHandler", true);
enableGemFireMockObjectsAttributes.put("destroyOnEvent", new Class[] { ContextClosedEvent.class });
enableGemFireMockObjectsAttributes.put("useSingletonCache", true);
AnnotationMetadata mockAnnotationMetadata = mock(AnnotationMetadata.class);
@@ -69,7 +66,7 @@ public class GemFireMockObjectsConfigurationUnitTests {
configuration.setImportMetadata(mockAnnotationMetadata);
assertThat(configuration.isSuppressOnContextClosedEvent()).isTrue();
assertThat(configuration.getConfiguredDestroyEventTypes()).containsExactly(ContextClosedEvent.class);
assertThat(configuration.isUseSingletonCacheConfigured()).isTrue();
verify(mockAnnotationMetadata, times(1))
@@ -77,36 +74,4 @@ public class GemFireMockObjectsConfigurationUnitTests {
verify(mockAnnotationMetadata, times(1))
.getAnnotationAttributes(eq(EnableGemFireMockObjects.class.getName()));
}
@Test
public void destroysGemFireMockObjectsWhenSuppressOnContextClosedEventIsFalse() {
ContextClosedEvent mockEvent = mock(ContextClosedEvent.class);
GemFireMockObjectsConfiguration configuration = spy(new GemFireMockObjectsConfiguration());
doReturn(false).when(configuration).isSuppressOnContextClosedEvent();
doNothing().when(configuration).destroyGemFireMockObjects();
configuration.onApplicationEvent(mockEvent);
verify(configuration, times(1)).destroyGemFireMockObjects();
verify(configuration, times(1)).releaseMockObjectResources(eq(mockEvent));
}
@Test
public void doesNotDestroyGemFireMockObjectsWhenSuppressOnContextClosedEventIsTrue() {
ContextClosedEvent mockEvent = mock(ContextClosedEvent.class);
GemFireMockObjectsConfiguration configuration = spy(new GemFireMockObjectsConfiguration());
doReturn(true).when(configuration).isSuppressOnContextClosedEvent();
doNothing().when(configuration).destroyGemFireMockObjects();
configuration.onApplicationEvent(mockEvent);
verify(configuration, never()).destroyGemFireMockObjects();
verify(configuration, times(1)).releaseMockObjectResources(eq(mockEvent));
}
}