From 0907ecbe441b93f598d5651bce7887dff8439a8a Mon Sep 17 00:00:00 2001 From: John Blum Date: Sun, 9 Jul 2017 12:57:47 -0700 Subject: [PATCH] DATAGEODE-17 - Adapt to API changes in mapping subsystem. --- .../EntityDefinedRegionsConfiguration.java | 11 ++---- .../config/annotation/IndexConfiguration.java | 8 ++-- .../mapping/GemfirePersistentEntity.java | 7 ++-- .../mapping/GemfirePropertyValueProvider.java | 6 +-- .../gemfire/mapping/MappingPdxSerializer.java | 37 +++++++++--------- .../data/gemfire/mapping/Regions.java | 9 +++-- .../repository/query/GemfireQueryMethod.java | 5 +-- .../support/GemfireRepositoryFactory.java | 10 ++--- .../GemfireMappingContextUnitTests.java | 29 ++++++-------- .../GemfirePersistentEntityUnitTests.java | 37 +++++++++--------- .../MappingPdxSerializerUnitTests.java | 38 +++++++++++++------ .../data/gemfire/mapping/RegionsTest.java | 13 +++++-- .../DefaultGemfireEntityInformationTest.java | 20 +++++----- .../query/GemfireQueryCreatorUnitTests.java | 7 ++-- 14 files changed, 122 insertions(+), 115 deletions(-) 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 f3cdb35f..04e65921 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 @@ -22,7 +22,6 @@ import static org.springframework.data.gemfire.util.ArrayUtils.defaultIfEmpty; import static org.springframework.data.gemfire.util.ArrayUtils.nullSafeArray; import static org.springframework.data.gemfire.util.CollectionUtils.nullSafeMap; import static org.springframework.data.gemfire.util.RuntimeExceptionFactory.newIllegalArgumentException; -import static org.springframework.data.gemfire.util.RuntimeExceptionFactory.newIllegalStateException; import java.lang.annotation.Annotation; import java.util.Collections; @@ -242,9 +241,7 @@ public class EntityDefinedRegionsConfiguration /* (non-Javadoc) */ protected GemfirePersistentEntity getPersistentEntity(Class persistentEntityType) { - - return resolveMappingContext().getPersistentEntity(persistentEntityType).orElseThrow( - () -> newIllegalStateException("PersistentEntity for type [%s] not found", persistentEntityType)); + return resolveMappingContext().getPersistentEntity(persistentEntityType); } /* (non-Javadoc) */ @@ -523,16 +520,16 @@ public class EntityDefinedRegionsConfiguration /* (non-Javadoc) */ protected Class resolveDomainType(GemfirePersistentEntity persistentEntity) { - return Optional.of(persistentEntity.getType()).orElse(Object.class); + return Optional.ofNullable(persistentEntity.getType()).orElse(Object.class); } /* (non-Javadoc) */ @SuppressWarnings("unchecked") protected Class resolveIdType(GemfirePersistentEntity persistentEntity) { - return (Class) persistentEntity.getIdProperty() + return Optional.ofNullable(persistentEntity.getIdProperty()) .map(idProperty -> ((GemfirePersistentProperty) idProperty).getActualType()) - .orElse(Object.class); + .orElse((Class) Object.class); } /* (non-Javadoc) */ diff --git a/src/main/java/org/springframework/data/gemfire/config/annotation/IndexConfiguration.java b/src/main/java/org/springframework/data/gemfire/config/annotation/IndexConfiguration.java index f28a531b..d274f5db 100644 --- a/src/main/java/org/springframework/data/gemfire/config/annotation/IndexConfiguration.java +++ b/src/main/java/org/springframework/data/gemfire/config/annotation/IndexConfiguration.java @@ -137,19 +137,21 @@ public class IndexConfiguration extends EntityDefinedRegionsConfiguration { localPersistentEntity.doWithProperties((PropertyHandler) persistentProperty -> { - Optional idAnnotation = persistentProperty.findAnnotation(Id.class); + Optional idAnnotation = Optional.ofNullable(persistentProperty.findAnnotation(Id.class)); idAnnotation.ifPresent(id -> registerIndexBeanDefinition(enableIndexingAttributes, localPersistentEntity, persistentProperty, IndexType.KEY, id, registry)); - Optional indexedAnnotation = persistentProperty.findAnnotation(Indexed.class); + Optional indexedAnnotation = + Optional.ofNullable(persistentProperty.findAnnotation(Indexed.class)); indexedAnnotation.ifPresent(indexed -> registerIndexBeanDefinition(enableIndexingAttributes, localPersistentEntity, persistentProperty, indexed.type(), indexed, registry)); - Optional luceneIndexedAnnotation = persistentProperty.findAnnotation(LuceneIndexed.class); + Optional luceneIndexedAnnotation = + Optional.ofNullable(persistentProperty.findAnnotation(LuceneIndexed.class)); luceneIndexedAnnotation.ifPresent(luceneIndexed -> registerLuceneIndexBeanDefinition(enableIndexingAttributes, localPersistentEntity, diff --git a/src/main/java/org/springframework/data/gemfire/mapping/GemfirePersistentEntity.java b/src/main/java/org/springframework/data/gemfire/mapping/GemfirePersistentEntity.java index a3302164..bebe913f 100644 --- a/src/main/java/org/springframework/data/gemfire/mapping/GemfirePersistentEntity.java +++ b/src/main/java/org/springframework/data/gemfire/mapping/GemfirePersistentEntity.java @@ -25,10 +25,10 @@ import org.springframework.core.annotation.AnnotatedElementUtils; import org.springframework.core.annotation.AnnotationAttributes; import org.springframework.core.annotation.AnnotationUtils; import org.springframework.data.gemfire.mapping.annotation.Region; +import org.springframework.data.mapping.MappingException; import org.springframework.data.mapping.PersistentEntity; import org.springframework.data.mapping.PersistentProperty; import org.springframework.data.mapping.model.BasicPersistentEntity; -import org.springframework.data.mapping.model.MappingException; import org.springframework.data.util.TypeInformation; /** @@ -149,11 +149,10 @@ public class GemfirePersistentEntity extends BasicPersistentEntity optionalIdProperty = getIdProperty(); - if (optionalIdProperty.isPresent()) { - GemfirePersistentProperty idProperty = getIdProperty().get(); + GemfirePersistentProperty idProperty = getIdProperty(); + if (idProperty != null) { if (idProperty.isExplicitIdProperty()) { if (property.isExplicitIdProperty()) { throw new MappingException(String.format( diff --git a/src/main/java/org/springframework/data/gemfire/mapping/GemfirePropertyValueProvider.java b/src/main/java/org/springframework/data/gemfire/mapping/GemfirePropertyValueProvider.java index 10fc12ed..3277d0f9 100644 --- a/src/main/java/org/springframework/data/gemfire/mapping/GemfirePropertyValueProvider.java +++ b/src/main/java/org/springframework/data/gemfire/mapping/GemfirePropertyValueProvider.java @@ -16,8 +16,6 @@ package org.springframework.data.gemfire.mapping; -import java.util.Optional; - import org.apache.geode.pdx.PdxReader; import org.springframework.data.mapping.model.PropertyValueProvider; import org.springframework.util.Assert; @@ -49,7 +47,7 @@ class GemfirePropertyValueProvider implements PropertyValueProvider Optional getPropertyValue(GemfirePersistentProperty property) { - return Optional.ofNullable((T) reader.readField(property.getName())); + public T getPropertyValue(GemfirePersistentProperty property) { + return (T) reader.readField(property.getName()); } } diff --git a/src/main/java/org/springframework/data/gemfire/mapping/MappingPdxSerializer.java b/src/main/java/org/springframework/data/gemfire/mapping/MappingPdxSerializer.java index 09a26ce2..67b540b4 100644 --- a/src/main/java/org/springframework/data/gemfire/mapping/MappingPdxSerializer.java +++ b/src/main/java/org/springframework/data/gemfire/mapping/MappingPdxSerializer.java @@ -15,11 +15,8 @@ */ package org.springframework.data.gemfire.mapping; -import static org.springframework.data.gemfire.util.RuntimeExceptionFactory.newIllegalArgumentException; - import java.util.Collections; import java.util.Map; -import java.util.Optional; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; @@ -33,11 +30,11 @@ import org.springframework.core.convert.ConversionService; import org.springframework.core.convert.support.DefaultConversionService; import org.springframework.data.convert.EntityInstantiator; import org.springframework.data.convert.EntityInstantiators; +import org.springframework.data.mapping.MappingException; import org.springframework.data.mapping.PersistentEntity; import org.springframework.data.mapping.PersistentPropertyAccessor; import org.springframework.data.mapping.PropertyHandler; import org.springframework.data.mapping.model.ConvertingPropertyAccessor; -import org.springframework.data.mapping.model.MappingException; import org.springframework.data.mapping.model.PersistentEntityParameterValueProvider; import org.springframework.data.mapping.model.SpELContext; import org.springframework.util.Assert; @@ -185,21 +182,22 @@ public class MappingPdxSerializer implements PdxSerializer, ApplicationContextAw GemfirePersistentEntity entity = getPersistentEntity(type); Object instance = getInstantiatorFor(entity).createInstance(entity, - new PersistentEntityParameterValueProvider<>(entity, new GemfirePropertyValueProvider(reader), - Optional.empty())); + new PersistentEntityParameterValueProvider<>(entity, new GemfirePropertyValueProvider(reader), null)); PersistentPropertyAccessor propertyAccessor = new ConvertingPropertyAccessor(entity.getPropertyAccessor(instance), getConversionService()); entity.doWithProperties((PropertyHandler) persistentProperty -> { + if (!entity.isConstructorArgument(persistentProperty)) { + PdxSerializer customSerializer = getCustomSerializer(persistentProperty.getType()); Object value = null; try { if (log.isDebugEnabled()) { - log.debug(String.format("setting property [%1$s] for entity [%2$s] of type [%3$s] from PDX%4$s", + log.debug(String.format("Setting property [%1$s] for entity [%2$s] of type [%3$s] from PDX%4$s", persistentProperty.getName(), instance, type, (customSerializer != null ? String.format(" using custom PdxSerializer [%1$s]", customSerializer) : ""))); } @@ -209,10 +207,10 @@ public class MappingPdxSerializer implements PdxSerializer, ApplicationContextAw : reader.readField(persistentProperty.getName())); if (log.isDebugEnabled()) { - log.debug(String.format("with value [%1$s]", value)); + log.debug(String.format("... with value [%s]", value)); } - propertyAccessor.setProperty(persistentProperty, Optional.ofNullable(value)); + propertyAccessor.setProperty(persistentProperty, value); } catch (Exception e) { throw new MappingException(String.format( @@ -239,9 +237,10 @@ public class MappingPdxSerializer implements PdxSerializer, ApplicationContextAw new ConvertingPropertyAccessor(entity.getPropertyAccessor(value), getConversionService()); entity.doWithProperties((PropertyHandler) persistentProperty -> { + PdxSerializer customSerializer = getCustomSerializer(persistentProperty.getType()); - Optional propertyValue = null; + Object propertyValue = null; try { propertyValue = propertyAccessor.getProperty(persistentProperty); @@ -253,28 +252,27 @@ public class MappingPdxSerializer implements PdxSerializer, ApplicationContextAw } if (customSerializer != null) { - customSerializer.toData(propertyValue.orElse(null), writer); + customSerializer.toData(propertyValue, writer); } else { - writer.writeField(persistentProperty.getName(), propertyValue.orElse(null), + writer.writeField(persistentProperty.getName(), propertyValue, (Class) persistentProperty.getType()); } } catch (Exception e) { - Object resolvedPropertyValue = (propertyValue != null ? propertyValue.orElse(null) : null); - throw new MappingException(String.format( "While serializing entity property [%1$s] value [%2$s] of type [%3$s] to PDX%4$s", - persistentProperty.getName(), resolvedPropertyValue, value.getClass(), + persistentProperty.getName(), propertyValue, value.getClass(), (customSerializer != null ? String.format(" using custom PdxSerializer [%1$s].", customSerializer.getClass().getName()) : ".")), e); } }); - Optional idProperty = entity.getIdProperty(); + GemfirePersistentProperty idProperty = entity.getIdProperty(); - idProperty.ifPresent(gemfirePersistentProperty -> - writer.markIdentityField(gemfirePersistentProperty.getName())); + if (idProperty != null) { + writer.markIdentityField(idProperty.getName()); + } return true; } @@ -326,7 +324,6 @@ public class MappingPdxSerializer implements PdxSerializer, ApplicationContextAw * @see #getMappingContext() */ protected GemfirePersistentEntity getPersistentEntity(Class entityType) { - return getMappingContext().getPersistentEntity(entityType).orElseThrow( - () -> newIllegalArgumentException("Unable to resolve PersistentEntity for type [%]", entityType)); + return getMappingContext().getPersistentEntity(entityType); } } diff --git a/src/main/java/org/springframework/data/gemfire/mapping/Regions.java b/src/main/java/org/springframework/data/gemfire/mapping/Regions.java index 52e59e83..f3f12f2f 100644 --- a/src/main/java/org/springframework/data/gemfire/mapping/Regions.java +++ b/src/main/java/org/springframework/data/gemfire/mapping/Regions.java @@ -16,12 +16,11 @@ package org.springframework.data.gemfire.mapping; -import static org.springframework.data.gemfire.util.RuntimeExceptionFactory.newIllegalArgumentException; - import java.util.Collections; import java.util.HashMap; import java.util.Iterator; import java.util.Map; +import java.util.Optional; import org.apache.geode.cache.Region; import org.springframework.data.mapping.context.MappingContext; @@ -74,10 +73,11 @@ public class Regions implements Iterable> { */ @SuppressWarnings("unchecked") public Region getRegion(Class entityType) { + Assert.notNull(entityType, "Entity type must not be null"); - String regionName = this.mappingContext.getPersistentEntity(entityType).map((entity) -> entity.getRegionName()) - .orElseGet(entityType::getSimpleName); + String regionName = Optional.ofNullable(this.mappingContext.getPersistentEntity(entityType)) + .map(entity -> entity.getRegionName()).orElseGet(entityType::getSimpleName); return (Region) this.regions.get(regionName); } @@ -92,6 +92,7 @@ public class Regions implements Iterable> { */ @SuppressWarnings("unchecked") public Region getRegion(String namePath) { + Assert.hasText(namePath, "Region name/path is required"); return (Region) this.regions.get(namePath); diff --git a/src/main/java/org/springframework/data/gemfire/repository/query/GemfireQueryMethod.java b/src/main/java/org/springframework/data/gemfire/repository/query/GemfireQueryMethod.java index 76086539..491055ad 100644 --- a/src/main/java/org/springframework/data/gemfire/repository/query/GemfireQueryMethod.java +++ b/src/main/java/org/springframework/data/gemfire/repository/query/GemfireQueryMethod.java @@ -67,9 +67,8 @@ public class GemfireQueryMethod extends QueryMethod { assertNonPagingQueryMethod(method); this.method = method; - this.entity = mappingContext.getPersistentEntity(getDomainClass()).orElseThrow( - () -> new IllegalArgumentException(String.format("Failed to resolve PersistentEntity for type [%s]", - getDomainClass()))); + + this.entity = mappingContext.getPersistentEntity(getDomainClass()); } /** diff --git a/src/main/java/org/springframework/data/gemfire/repository/support/GemfireRepositoryFactory.java b/src/main/java/org/springframework/data/gemfire/repository/support/GemfireRepositoryFactory.java index 46706a10..c457d4dc 100644 --- a/src/main/java/org/springframework/data/gemfire/repository/support/GemfireRepositoryFactory.java +++ b/src/main/java/org/springframework/data/gemfire/repository/support/GemfireRepositoryFactory.java @@ -16,7 +16,6 @@ package org.springframework.data.gemfire.repository.support; -import static org.springframework.data.gemfire.util.RuntimeExceptionFactory.newIllegalArgumentException; import static org.springframework.data.gemfire.util.RuntimeExceptionFactory.newIllegalStateException; import java.io.Serializable; @@ -84,9 +83,8 @@ public class GemfireRepositoryFactory extends RepositoryFactorySupport { @SuppressWarnings("unchecked") public GemfireEntityInformation getEntityInformation(Class domainClass) { - GemfirePersistentEntity entity = (GemfirePersistentEntity) mappingContext.getPersistentEntity(domainClass) - .orElseThrow(() -> newIllegalArgumentException("Unable to resolve PersistentEntity for type [%s]", - domainClass)); + GemfirePersistentEntity entity = + (GemfirePersistentEntity) mappingContext.getPersistentEntity(domainClass); return new DefaultGemfireEntityInformation<>(entity); } @@ -108,9 +106,7 @@ public class GemfireRepositoryFactory extends RepositoryFactorySupport { GemfireTemplate getTemplate(RepositoryMetadata metadata) { - GemfirePersistentEntity entity = mappingContext.getPersistentEntity(metadata.getDomainType()) - .orElseThrow(() -> newIllegalArgumentException("Unable to resolve PersistentEntity for type [%s]", - metadata.getDomainType())); + GemfirePersistentEntity entity = mappingContext.getPersistentEntity(metadata.getDomainType()); String entityRegionName = entity.getRegionName(); String repositoryRegionName = getRepositoryRegionName(metadata.getRepositoryInterface()); diff --git a/src/test/java/org/springframework/data/gemfire/mapping/GemfireMappingContextUnitTests.java b/src/test/java/org/springframework/data/gemfire/mapping/GemfireMappingContextUnitTests.java index 9174f728..048984e5 100644 --- a/src/test/java/org/springframework/data/gemfire/mapping/GemfireMappingContextUnitTests.java +++ b/src/test/java/org/springframework/data/gemfire/mapping/GemfireMappingContextUnitTests.java @@ -16,18 +16,16 @@ package org.springframework.data.gemfire.mapping; -import static org.assertj.core.api.Assertions.*; -import static org.springframework.data.gemfire.util.RuntimeExceptionFactory.*; - -import lombok.Data; +import static org.assertj.core.api.Assertions.assertThat; import java.math.BigDecimal; import java.math.BigInteger; -import java.util.Optional; import org.junit.Test; import org.springframework.data.gemfire.mapping.annotation.Region; +import lombok.Data; + /** * Unit tests for {@link GemfireMappingContext} class. * @@ -43,32 +41,29 @@ public class GemfireMappingContextUnitTests { @Test @SuppressWarnings("unchecked") public void getPersistentEntityForPerson() throws Exception { - + GemfirePersistentEntity personPersistentEntity = - (GemfirePersistentEntity) mappingContext.getPersistentEntity(Person.class).orElseThrow( - () -> newIllegalStateException("Unable to resolve PersistentEntity for type [%s]", - Person.class.getName())); + (GemfirePersistentEntity) mappingContext.getPersistentEntity(Person.class); assertThat(personPersistentEntity).isNotNull(); assertThat(personPersistentEntity.getRegionName()).isEqualTo("People"); - Optional namePersistentProperty = - personPersistentEntity.getPersistentProperty("name"); + GemfirePersistentProperty namePersistentProperty = personPersistentEntity.getPersistentProperty("name"); - assertThat(namePersistentProperty.isPresent()).isTrue(); - assertThat(namePersistentProperty.get().isEntity()).isFalse(); - assertThat(namePersistentProperty.get().getName()).isEqualTo("name"); - assertThat(namePersistentProperty.get().getOwner()).isEqualTo(personPersistentEntity); + assertThat(namePersistentProperty).isNotNull(); + assertThat(namePersistentProperty.isEntity()).isFalse(); + assertThat(namePersistentProperty.getName()).isEqualTo("name"); + assertThat(namePersistentProperty.getOwner()).isEqualTo(personPersistentEntity); } @Test public void getPersistentEntityForBigDecimal() { - assertThat(mappingContext.getPersistentEntity(BigDecimal.class).isPresent()).isFalse(); + assertThat(mappingContext.getPersistentEntity(BigDecimal.class)).isNull(); } @Test public void getPersistentEntityForBigInteger() { - assertThat(mappingContext.getPersistentEntity(BigInteger.class).isPresent()).isFalse(); + assertThat(mappingContext.getPersistentEntity(BigInteger.class)).isNull(); } @Data diff --git a/src/test/java/org/springframework/data/gemfire/mapping/GemfirePersistentEntityUnitTests.java b/src/test/java/org/springframework/data/gemfire/mapping/GemfirePersistentEntityUnitTests.java index eeeecec1..e220a8cc 100644 --- a/src/test/java/org/springframework/data/gemfire/mapping/GemfirePersistentEntityUnitTests.java +++ b/src/test/java/org/springframework/data/gemfire/mapping/GemfirePersistentEntityUnitTests.java @@ -19,11 +19,9 @@ package org.springframework.data.gemfire.mapping; import static org.assertj.core.api.Assertions.assertThat; import static org.hamcrest.Matchers.is; import static org.hamcrest.Matchers.nullValue; -import static org.springframework.data.gemfire.util.RuntimeExceptionFactory.newIllegalStateException; import java.math.BigDecimal; import java.math.BigInteger; -import java.util.Optional; import org.junit.Rule; import org.junit.Test; @@ -31,7 +29,7 @@ import org.junit.rules.ExpectedException; import org.springframework.data.annotation.Id; import org.springframework.data.gemfire.mapping.annotation.Region; import org.springframework.data.mapping.IdentifierAccessor; -import org.springframework.data.mapping.model.MappingException; +import org.springframework.data.mapping.MappingException; import org.springframework.data.util.ClassTypeInformation; /** @@ -62,8 +60,7 @@ public class GemfirePersistentEntityUnitTests { @SuppressWarnings("unchecked") protected GemfirePersistentEntity getMappingContextPersistentEntity(Class type) { - return (GemfirePersistentEntity) this.mappingContext.getPersistentEntity(type).orElseThrow( - () -> newIllegalStateException("Unable to resolve PersistentEntity for type [%s]", type)); + return (GemfirePersistentEntity) this.mappingContext.getPersistentEntity(type); } protected GemfirePersistentEntity newPersistentEntity(Class type) { @@ -96,25 +93,26 @@ public class GemfirePersistentEntityUnitTests { assertThat(entity).isNotNull(); assertThat(entity.getRegionName()).isEqualTo("Example"); - Optional currency = entity.getPersistentProperty("currency"); + GemfirePersistentProperty currency = entity.getPersistentProperty("currency"); - assertThat(currency.isPresent()).isTrue(); - assertThat(currency.get().isEntity()).isFalse(); + assertThat(currency).isNotNull(); + assertThat(currency.isEntity()).isFalse(); } @Test @SuppressWarnings("unchecked") public void bigIntegerPersistentPropertyIsNotAnEntity() { + GemfirePersistentEntity entity = getMappingContextPersistentEntity(ExampleDomainObject.class); assertThat(entity).isNotNull(); assertThat(entity.getRegionName()).isEqualTo("Example"); - Optional bigNumber = entity.getPersistentProperty("bigNumber"); + GemfirePersistentProperty bigNumber = entity.getPersistentProperty("bigNumber"); - assertThat(bigNumber.isPresent()).isTrue(); - assertThat(bigNumber.get().isEntity()).isFalse(); + assertThat(bigNumber).isNotNull(); + assertThat(bigNumber.isEntity()).isFalse(); } /** @@ -122,9 +120,10 @@ public class GemfirePersistentEntityUnitTests { */ @Test public void identifierForNonIdAnnotatedEntityWithNoIdFieldOrPropertyIsNull() { + IdentifierAccessor identifierAccessor = getIdentifierAccessor(new NonRegionAnnotatedEntity()); - assertThat(identifierAccessor.getIdentifier().orElse(null)).isNull(); + assertThat(identifierAccessor.getIdentifier()).isNull(); } /** @@ -132,9 +131,10 @@ public class GemfirePersistentEntityUnitTests { */ @Test public void identifierForNonIdAnnotatedEntityWithIdFieldIsNotNull() { + IdentifierAccessor identifierAccessor = getIdentifierAccessor(new NonIdAnnotatedIdFieldEntity()); - assertThat(identifierAccessor.getIdentifier().orElse(null)).isEqualTo(123L); + assertThat(identifierAccessor.getIdentifier()).isEqualTo(123L); } /** @@ -142,22 +142,25 @@ public class GemfirePersistentEntityUnitTests { */ @Test public void identifierForNonIdAnnotatedEntityWithIdPropertyIsNotNull() { + IdentifierAccessor identifierAccessor = getIdentifierAccessor(new NonIdAnnotatedIdGetterEntity()); - assertThat(identifierAccessor.getIdentifier().orElse(null)).isEqualTo(456L); + assertThat(identifierAccessor.getIdentifier()).isEqualTo(456L); } @Test public void identifierForIdAnnotatedFieldAndPropertyEntityShouldNotConflict() { + IdentifierAccessor identifierAccessor = getIdentifierAccessor(new IdAnnotatedFieldAndPropertyEntity()); - assertThat(identifierAccessor.getIdentifier().orElse(null)).isEqualTo(1L); + assertThat(identifierAccessor.getIdentifier()).isEqualTo(1L); } @Test public void identifierForAmbiguousIdAnnotatedFieldAndIdAnnotatedPropertyEntityThrowsMappingException() { - AmbiguousIdAnnotatedFieldAndIdAnnotatedPropertyEntity entity - = new AmbiguousIdAnnotatedFieldAndIdAnnotatedPropertyEntity(); + + AmbiguousIdAnnotatedFieldAndIdAnnotatedPropertyEntity entity = + new AmbiguousIdAnnotatedFieldAndIdAnnotatedPropertyEntity(); String expectedMessage = String.format("Attempt to add explicit id property [ssn] but already have id property [id] registered as explicit;" + " Please check your object [%s] mapping configuration", entity.getClass().getName()); diff --git a/src/test/java/org/springframework/data/gemfire/mapping/MappingPdxSerializerUnitTests.java b/src/test/java/org/springframework/data/gemfire/mapping/MappingPdxSerializerUnitTests.java index d9faf76e..07616527 100644 --- a/src/test/java/org/springframework/data/gemfire/mapping/MappingPdxSerializerUnitTests.java +++ b/src/test/java/org/springframework/data/gemfire/mapping/MappingPdxSerializerUnitTests.java @@ -28,7 +28,6 @@ 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.RuntimeExceptionFactory.newIllegalArgumentException; -import static org.springframework.data.gemfire.util.RuntimeExceptionFactory.newIllegalStateException; import java.util.Collections; @@ -47,7 +46,7 @@ import org.springframework.core.convert.support.GenericConversionService; import org.springframework.data.convert.EntityInstantiator; import org.springframework.data.gemfire.repository.sample.Address; import org.springframework.data.gemfire.repository.sample.Person; -import org.springframework.data.mapping.model.MappingException; +import org.springframework.data.mapping.MappingException; import org.springframework.data.mapping.model.ParameterValueProvider; /** @@ -78,7 +77,7 @@ public class MappingPdxSerializerUnitTests { MappingPdxSerializer serializer; @Rule - public ExpectedException expectedException = ExpectedException.none(); + public ExpectedException exception = ExpectedException.none(); @Mock EntityInstantiator mockInstantiator; @@ -102,6 +101,7 @@ public class MappingPdxSerializerUnitTests { @Test public void createFullyInitialized() { + ConversionService mockConversionService = mock(ConversionService.class); GemfireMappingContext mockMappingContext = mock(GemfireMappingContext.class); @@ -114,6 +114,7 @@ public class MappingPdxSerializerUnitTests { @Test public void createWithNullConversionService() { + GemfireMappingContext mockMappingContext = mock(GemfireMappingContext.class); MappingPdxSerializer pdxSerializer = MappingPdxSerializer.create(mockMappingContext, null); @@ -125,6 +126,7 @@ public class MappingPdxSerializerUnitTests { @Test public void createWithNullMappingContext() { + ConversionService mockConversionService = mock(ConversionService.class); MappingPdxSerializer pdxSerializer = MappingPdxSerializer.create(null, mockConversionService); @@ -136,6 +138,7 @@ public class MappingPdxSerializerUnitTests { @Test public void createWithNullConversionServiceAndNullMappingContext() { + MappingPdxSerializer pdxSerializer = MappingPdxSerializer.create(null, null); assertThat(pdxSerializer).isNotNull(); @@ -146,11 +149,14 @@ public class MappingPdxSerializerUnitTests { @Test @SuppressWarnings("unchecked") public void usesRegisteredInstantiator() { + Address address = new Address(); + address.city = "London"; address.zipCode = "01234"; Person person = new Person(1L, "Oliver", "Gierke"); + person.address = address; when(mockInstantiator.createInstance(any(GemfirePersistentEntity.class), any(ParameterValueProvider.class))) @@ -160,18 +166,18 @@ public class MappingPdxSerializerUnitTests { serializer.fromData(Person.class, mockReader); - GemfirePersistentEntity persistentEntity = context.getPersistentEntity(Person.class) - .orElseThrow(() -> newIllegalStateException("Unable to resolve PersistentEntity for type [%s]", - Person.class.getName())); + GemfirePersistentEntity persistentEntity = context.getPersistentEntity(Person.class); verify(mockInstantiator, times(1)).createInstance(eq(persistentEntity), any(ParameterValueProvider.class)); + verify(mockAddressSerializer, times(1)).fromData(eq(Address.class), any(PdxReader.class)); } @Test @SuppressWarnings("unchecked") public void fromDataMapsPdxDataToApplicationDomainObject() { + Address expectedAddress = new Address(); expectedAddress.city = "Portland"; @@ -207,6 +213,7 @@ public class MappingPdxSerializerUnitTests { @Test @SuppressWarnings("unchecked") public void fromDataHandlesExceptionProperly() { + when(mockInstantiator.createInstance(any(GemfirePersistentEntity.class), any(ParameterValueProvider.class))) .thenReturn(new Person(null, null, null)); @@ -215,9 +222,9 @@ public class MappingPdxSerializerUnitTests { serializer.setGemfireInstantiators(Collections.singletonMap(Person.class, mockInstantiator)); try { - expectedException.expect(MappingException.class); - expectedException.expectCause(isA(IllegalArgumentException.class)); - expectedException.expectMessage(String.format( + exception.expect(MappingException.class); + exception.expectCause(isA(IllegalArgumentException.class)); + exception.expectMessage(String.format( "While setting value [null] of property [id] for entity of type [%s] from PDX", Person.class)); serializer.fromData(Person.class, mockReader); @@ -225,17 +232,21 @@ public class MappingPdxSerializerUnitTests { finally { verify(mockInstantiator, times(1)) .createInstance(any(GemfirePersistentEntity.class), any(ParameterValueProvider.class)); + verify(mockReader, times(1)).readField(eq("id")); } } @Test public void toDataSerializesApplicationDomainObjectToPdx() { + Address address = new Address(); + address.city = "Portland"; address.zipCode = "12345"; Person jonDoe = new Person(1L, "Jon", "Doe"); + jonDoe.address = address; serializer.setCustomSerializers(Collections.singletonMap(Address.class, mockAddressSerializer)); @@ -251,20 +262,23 @@ public class MappingPdxSerializerUnitTests { @Test public void toDataHandlesExceptionProperly() { + Address address = new Address(); + address.city = "Portland"; address.zipCode = "12345"; Person jonDoe = new Person(1L, "Jon", "Doe"); + jonDoe.address = address; when(mockWriter.writeField(eq("address"), eq(address), eq(Address.class))) .thenThrow(newIllegalArgumentException("test")); try { - expectedException.expect(MappingException.class); - expectedException.expectCause(isA(IllegalArgumentException.class)); - expectedException.expectMessage(String.format( + exception.expect(MappingException.class); + exception.expectCause(isA(IllegalArgumentException.class)); + exception.expectMessage(String.format( "While serializing entity property [address] value [Portland, 12345] of type [%s] to PDX", Person.class)); diff --git a/src/test/java/org/springframework/data/gemfire/mapping/RegionsTest.java b/src/test/java/org/springframework/data/gemfire/mapping/RegionsTest.java index 78f88de0..c801f46c 100644 --- a/src/test/java/org/springframework/data/gemfire/mapping/RegionsTest.java +++ b/src/test/java/org/springframework/data/gemfire/mapping/RegionsTest.java @@ -27,7 +27,6 @@ import static org.mockito.Mockito.when; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import java.util.Optional; import org.apache.geode.cache.Region; import org.junit.After; @@ -101,30 +100,34 @@ public class RegionsTest { @Test public void getRegionByEntityTypeReturnsRegionForEntityRegionName() { + GemfirePersistentEntity mockPersistentEntity = mock(GemfirePersistentEntity.class); when(mockPersistentEntity.getRegionName()).thenReturn("Users"); - when(mockMappingContext.getPersistentEntity(eq(User.class))).thenReturn(Optional.of(mockPersistentEntity)); + when(mockMappingContext.getPersistentEntity(eq(User.class))).thenReturn(mockPersistentEntity); assertThat(regions.getRegion(User.class)).isEqualTo(mockUsers); } @Test public void getRegionByEntityTypeReturnsRegionForEntityTypeSimpleName() { - when(mockMappingContext.getPersistentEntity(any(Class.class))).thenReturn(Optional.empty()); + + when(mockMappingContext.getPersistentEntity(any(Class.class))).thenReturn(null); assertThat(regions.getRegion(Users.class)).isEqualTo(mockUsers); } @Test public void getRegionByEntityTypeReturnsNull() { - when(mockMappingContext.getPersistentEntity(any(Class.class))).thenReturn(Optional.empty()); + + when(mockMappingContext.getPersistentEntity(any(Class.class))).thenReturn(null); assertThat(regions.getRegion(Object.class)).isNull(); } @Test public void getRegionWithNullEntityTypeThrowsIllegalArgumentException() { + exception.expect(IllegalArgumentException.class); exception.expectCause(is(nullValue(Throwable.class))); exception.expectMessage("Entity type must not be null"); @@ -158,6 +161,7 @@ public class RegionsTest { @Test public void getRegionWithNullNameNullPathThrowsIllegalArgumentException() { + exception.expect(IllegalArgumentException.class); exception.expectCause(is(nullValue(Throwable.class))); exception.expectMessage("Region name/path is required"); @@ -167,6 +171,7 @@ public class RegionsTest { @Test public void iterateRegions() { + List actualRegions = new ArrayList<>(3); for (Region region : regions) { diff --git a/src/test/java/org/springframework/data/gemfire/repository/query/DefaultGemfireEntityInformationTest.java b/src/test/java/org/springframework/data/gemfire/repository/query/DefaultGemfireEntityInformationTest.java index 44ca59ee..adb99d72 100644 --- a/src/test/java/org/springframework/data/gemfire/repository/query/DefaultGemfireEntityInformationTest.java +++ b/src/test/java/org/springframework/data/gemfire/repository/query/DefaultGemfireEntityInformationTest.java @@ -20,7 +20,6 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; -import static org.springframework.data.gemfire.util.RuntimeExceptionFactory.newIllegalStateException; import java.io.Serializable; @@ -69,12 +68,12 @@ public class DefaultGemfireEntityInformationTest { @SuppressWarnings("unchecked") protected GemfirePersistentEntity newPersistentEntity(Class entityType) { - return (GemfirePersistentEntity) mappingContext.getPersistentEntity(entityType).orElseThrow( - () -> newIllegalStateException("Unable to resolve PersistentEntity for type [%s]", entityType)); + return (GemfirePersistentEntity) mappingContext.getPersistentEntity(entityType); } @Test public void interfaceBasedEntity() { + GemfireEntityInformation entityInfo = newEntityInformation(newPersistentEntity(Algorithm.class)); @@ -82,12 +81,13 @@ public class DefaultGemfireEntityInformationTest { assertEquals("Algorithms", entityInfo.getRegionName()); assertTrue(Algorithm.class.isAssignableFrom(entityInfo.getJavaType())); assertEquals(String.class, entityInfo.getIdType()); - assertThat(entityInfo.getId(new QuickSort()).orElse(null)).isEqualTo("QuickSort"); - assertThat(entityInfo.getId(newAlgorithm("Quick Sort")).orElse(null)).isEqualTo("Quick Sort"); + assertThat(entityInfo.getId(new QuickSort())).isEqualTo("QuickSort"); + assertThat(entityInfo.getId(newAlgorithm("Quick Sort"))).isEqualTo("Quick Sort"); } @Test public void classBasedEntity() { + GemfireEntityInformation entityInfo = newEntityInformation(newPersistentEntity(Animal.class)); @@ -95,11 +95,12 @@ public class DefaultGemfireEntityInformationTest { assertEquals("Animal", entityInfo.getRegionName()); assertEquals(Animal.class, entityInfo.getJavaType()); assertEquals(Long.class, entityInfo.getIdType()); - assertThat(entityInfo.getId(newAnimal(1L, "Tyger")).orElse(null)).isEqualTo(1L); + assertThat(entityInfo.getId(newAnimal(1L, "Tyger"))).isEqualTo(1L); } @Test public void confusedDomainEntityTypedWithLongId() { + GemfireEntityInformation entityInfo = newEntityInformation(newPersistentEntity(ConfusedDomainEntity.class)); @@ -107,12 +108,13 @@ public class DefaultGemfireEntityInformationTest { assertEquals("ConfusedDomainEntity", entityInfo.getRegionName()); assertEquals(ConfusedDomainEntity.class, entityInfo.getJavaType()); assertEquals(Long.class, entityInfo.getIdType()); - assertThat(entityInfo.getId(new ConfusedDomainEntity(123L)).orElse(null)).isEqualTo(123L); + assertThat(entityInfo.getId(new ConfusedDomainEntity(123L))).isEqualTo(123L); } @Test @SuppressWarnings("all") public void confusedDomainEntityTypedStringId() { + GemfireEntityInformation entityInfo = newEntityInformation(newPersistentEntity(ConfusedDomainEntity.class)); @@ -121,8 +123,8 @@ public class DefaultGemfireEntityInformationTest { assertEquals(ConfusedDomainEntity.class, entityInfo.getJavaType()); //assertEquals(String.class, entityInfo.getIdType()); assertTrue(Long.class.equals(entityInfo.getIdType())); - assertThat(entityInfo.getId(new ConfusedDomainEntity(123L)).orElse(null)).isEqualTo(123L); - assertThat(entityInfo.getId(new ConfusedDomainEntity("248")).orElse(null)).isEqualTo(248L); + assertThat(entityInfo.getId(new ConfusedDomainEntity(123L))).isEqualTo(123L); + assertThat(entityInfo.getId(new ConfusedDomainEntity("248"))).isEqualTo(248L); } @SuppressWarnings("unused") diff --git a/src/test/java/org/springframework/data/gemfire/repository/query/GemfireQueryCreatorUnitTests.java b/src/test/java/org/springframework/data/gemfire/repository/query/GemfireQueryCreatorUnitTests.java index e851e29d..3c3a4467 100644 --- a/src/test/java/org/springframework/data/gemfire/repository/query/GemfireQueryCreatorUnitTests.java +++ b/src/test/java/org/springframework/data/gemfire/repository/query/GemfireQueryCreatorUnitTests.java @@ -18,7 +18,6 @@ package org.springframework.data.gemfire.repository.query; import static org.hamcrest.CoreMatchers.equalTo; import static org.hamcrest.CoreMatchers.is; import static org.junit.Assert.assertThat; -import static org.springframework.data.gemfire.util.RuntimeExceptionFactory.newIllegalStateException; import org.junit.Before; import org.junit.Test; @@ -40,13 +39,12 @@ public class GemfireQueryCreatorUnitTests { @Before @SuppressWarnings("unchecked") public void setUp() { - entity = (GemfirePersistentEntity) new GemfireMappingContext().getPersistentEntity(Person.class) - .orElseThrow(() -> newIllegalStateException("Unable to resolve PersistentEntity for type [%s]", - Person.class)); + entity = (GemfirePersistentEntity) new GemfireMappingContext().getPersistentEntity(Person.class); } @Test public void createsQueryForSimplePropertyReferenceCorrectly() { + PartTree partTree = new PartTree("findByLastname", Person.class); GemfireQueryCreator queryCreator = new GemfireQueryCreator(partTree, entity); @@ -58,6 +56,7 @@ public class GemfireQueryCreatorUnitTests { @Test public void createsQueryForNestedPropertyReferenceCorrectly() { + PartTree partTree = new PartTree("findPersonByAddressCity", Person.class); GemfireQueryCreator queryCreator = new GemfireQueryCreator(partTree, entity);