Rewrote tests for StandardBeanIntrospector

Author: SQiShER

src/main/java/de/danielbechler/diff/introspection/BeanPropertyException.java

@@ -19,8 +19,7 @@
 /**
  * @author Daniel Bechler
  */
-@SuppressWarnings("UnusedDeclaration")
-public class BeanPropertyException extends RuntimeException
+public abstract class BeanPropertyException extends RuntimeException
 {
 	private static final long serialVersionUID = 1L;
 

src/main/java/de/danielbechler/diff/introspection/BeanPropertyWriteException.java

@@ -22,7 +22,7 @@
 public class BeanPropertyWriteException extends BeanPropertyException
 {
 	private static final long serialVersionUID = 1L;
-	private final Object newValue;
+	private Object newValue;
 
 	public BeanPropertyWriteException(final Throwable cause, final Object newValue)
 	{
@@ -33,7 +33,7 @@ public BeanPropertyWriteException(final Throwable cause, final Object newValue)
 	@Override
 	public String getMessage()
 	{
-		return "Error while invoking write method. ";
+		return "Error while invoking write method. " + super.getMessage();
 	}
 
 	public Object getNewValue()

src/main/java/de/danielbechler/diff/introspection/StandardBeanIntrospector.java

@@ -89,7 +89,19 @@ private static PropertyAwareAccessor handlePropertyDescriptor(final PropertyDesc
 
 	private static boolean shouldSkip(final PropertyDescriptor descriptor)
 	{
-		return descriptor.getName().equals("class") || descriptor.getReadMethod() == null;
+		if (descriptor.getName().equals("class")) // Java & Groovy
+		{
+			return true;
+		}
+		if (descriptor.getName().equals("metaClass")) // Groovy
+		{
+			return true;
+		}
+		if (descriptor.getReadMethod() == null)
+		{
+			return true;
+		}
+		return false;
 	}
 
 	private static void handleObjectDiffPropertyAnnotation(final Method readMethod,

src/main/java/de/danielbechler/diff/introspection/DefaultPropertyAccessExceptionHandler.java renamed to src/main/java/de/danielbechler/diff/introspection/StandardPropertyAccessExceptionHandler.java

@@ -21,21 +21,19 @@
 import org.slf4j.LoggerFactory;
 
 @SuppressWarnings("UnusedDeclaration")
-public class DefaultPropertyAccessExceptionHandler implements BeanPropertyAccessExceptionHandler
+public class StandardPropertyAccessExceptionHandler implements BeanPropertyAccessExceptionHandler
 {
-	private static final Logger logger = LoggerFactory.getLogger(DefaultPropertyAccessExceptionHandler.class);
+	private static final Logger logger = LoggerFactory.getLogger(StandardPropertyAccessExceptionHandler.class);
 
-	public DiffNode onPropertyWriteException(final BeanPropertyWriteException exception,
-											 final DiffNode propertyNode)
+	public DiffNode onPropertyWriteException(final BeanPropertyWriteException exception, final DiffNode node)
 	{
 		final Object newValue = exception.getNewValue();
 		final String propertyName = exception.getPropertyName();
 		logger.info("Couldn't set new value '{}' for property '{}'", newValue, propertyName);
 		throw exception;
 	}
 
-	public DiffNode onPropertyReadException(final BeanPropertyReadException exception,
-											final DiffNode propertyNode)
+	public DiffNode onPropertyReadException(final BeanPropertyReadException exception, final DiffNode node)
 	{
 		throw exception;
 	}

src/test/java/de/danielbechler/diff/introspection/IntrospectionServiceTest.groovy

@@ -16,6 +16,7 @@
 
 package de.danielbechler.diff.introspection
 
+import de.danielbechler.diff.ObjectDifferBuilder
 import de.danielbechler.diff.access.RootAccessor
 import de.danielbechler.diff.access.TypeAwareAccessor
 import de.danielbechler.diff.circular.CircularReferenceMatchingMode
@@ -37,7 +38,8 @@ class IntrospectionServiceTest extends Specification {
 	@Shared
 	def primitiveWrapperTypes = [Integer, Short, Long, Boolean, Character, Byte, Double, Float]
 
-	def introspectionService = new IntrospectionService(null)
+	def objectDifferBuilder = Mock(ObjectDifferBuilder)
+	def introspectionService = new IntrospectionService(objectDifferBuilder)
 	def rootNode = new DiffNode(DiffNode.ROOT, RootAccessor.instance, ObjectWithString)
 	def childNode
 	def childAccessor = Mock(TypeAwareAccessor)
@@ -189,4 +191,12 @@ class IntrospectionServiceTest extends Specification {
 		expect:
 		  introspectionService.introspectorForNode(rootNode) == nodeIntrospector
 	}
+
+	def 'and() returns original ObjectDifferBuilder'() {
+		given:
+		  objectDifferBuilder = Mock(ObjectDifferBuilder)
+		  introspectionService = new IntrospectionService(objectDifferBuilder)
+		expect:
+		  introspectionService.and().is objectDifferBuilder
+	}
 }

src/test/java/de/danielbechler/diff/introspection/StandardBeanIntrospectorTest.groovy

@@ -17,10 +17,7 @@
 package de.danielbechler.diff.introspection
 
 import de.danielbechler.diff.access.PropertyAwareAccessor
-import de.danielbechler.diff.mock.ObjectWithInheritedPropertyAnnotation
-import de.danielbechler.diff.mock.ObjectWithPropertyAnnotations
 import de.danielbechler.diff.mock.ObjectWithString
-import de.danielbechler.diff.selector.BeanPropertyElementSelector
 import spock.lang.Specification
 
 import java.beans.BeanInfo
@@ -30,92 +27,74 @@ import java.beans.IntrospectionException
  * @author Daniel Bechler
  */
 public class StandardBeanIntrospectorTest extends Specification {
-	StandardBeanIntrospector introspector = new StandardBeanIntrospector()
-
-//	@Test(enabled = false)
-//	public void testIntrospectWithEqualsOnlyPropertyType() throws Exception {
-//		final Iterable<PropertyAwareAccessor> accessors = introspector.introspect(ObjectWithEqualsOnlyPropertyType.class);
-//		assertThat(accessors.iterator().hasNext(), is(true));
-////		final PropertyAwareAccessor propertyAwareAccessor = accessors.iterator().next();
-////		assertThat(propertyAwareAccessor.getComparisonStrategy(), instanceOf(EqualsOnlyComparisonStrategy.class));
-//	}
-//
-//	@Test
-//	public void testIntrospectWithEqualsOnlyPropertyTypeAndValueProviderMethod() throws Exception {
-//		final Object object = new Object()
-//		{
-//			public ObjectWithObjectDiffEqualsOnlyTypeAnnotationAndValueProviderMethod getValue() {
-//				return null;
-//			}
-//		};
-//
-//		final Iterable<PropertyAwareAccessor> accessors = introspector.introspect(object.getClass());
-//		assertThat(accessors.iterator().hasNext(), is(true));
-//
-//		final PropertyAwareAccessor propertyAwareAccessor = accessors.iterator().next();
-//
-////		final ComparisonStrategy comparisonStrategy = propertyAwareAccessor.getComparisonStrategy();
-////		assertThat(comparisonStrategy, is(instanceOf(EqualsOnlyComparisonStrategy.class)));
-//
-////		final EqualsOnlyComparisonStrategy equalsOnlyComparisonStrategy = (EqualsOnlyComparisonStrategy) comparisonStrategy;
-////		assertThat(equalsOnlyComparisonStrategy.getEqualsValueProviderMethod(), is(IsEqual.equalTo("foo")));
-//	}
-
-	class ObjectWithIgnoredProperty {
-		@ObjectDiffProperty(excluded = true)
-		def getProperty() {
+
+	def introspector = new StandardBeanIntrospector()
+
+	private Map<String, PropertyAwareAccessor> introspect(Class<?> type) {
+		introspector.introspect(type).collectEntries {
+			accessor -> [accessor.propertyName, accessor]
 		}
 	}
 
-	def 'excluded property'() {
+	def 'should return proper accessor for property'() {
 		when:
-		  PropertyAwareAccessor propertyAccessor = introspector.introspect(ObjectWithIgnoredProperty).find({
-			  it.propertyName == 'property' ? it : null
-		  }) as PropertyAwareAccessor
+		  def accessor = introspect(TypeWithOnlyOneProperty).get('value')
 		then:
-		  propertyAccessor.isExcluded()
+		  accessor.propertyName == 'value'
+		and:
+		  def target = new TypeWithOnlyOneProperty()
+		  accessor.get(target) == null
+		and:
+		  accessor.set(target, 'bar')
+		  accessor.get(target) == 'bar'
+		and:
+		  accessor.excluded == false
+		and:
+		  accessor.categories.isEmpty()
 	}
 
-	def 'Introspect With Property Annotations'() {
+	def 'should return PropertyAwareAccessors for each property of the given class'() {
 		when:
-		  Iterable<PropertyAwareAccessor> accessors = introspector.introspect(ObjectWithPropertyAnnotations.class);
+		  def accessors = introspect(TypeWithTwoProperties)
+		then:
+		  accessors.size() == 2
+		  accessors.get('foo') != null
+		  accessors.get('bar') != null
+	}
 
+	def 'should apply categories of ObjectDiffProperty annotation to accessor'() {
+		when:
+		  def accessor = introspect(TypeWithPropertyAnnotation).get('value')
 		then:
-		  for (final PropertyAwareAccessor accessor : accessors) {
-			  if (accessor.getElementSelector().equals(new BeanPropertyElementSelector("ignored"))) {
-				  assert accessor.isExcluded()
-			  } else if (accessor.getElementSelector().equals(new BeanPropertyElementSelector("categorized"))) {
-				  assert accessor.getCategories().size() == 1
-				  assert accessor.getCategories().containsAll(['foo'])
-			  } else if (accessor.getElementSelector().equals(new BeanPropertyElementSelector("item"))) {
-				  assert accessor.isExcluded() == false
-				  assert accessor.getCategories().isEmpty()
-			  } else if (accessor.getElementSelector().equals(new BeanPropertyElementSelector("key"))) {
-				  // no op
-			  } else if (accessor.getElementSelector().equals(new BeanPropertyElementSelector("value"))) {
-				  // no op
-			  } else {
-				  assert false: "Unexpected accessor: " + accessor.getElementSelector()
-			  }
-		  }
+		  accessor.categories.size() == 2
+		  accessor.categories.containsAll(['category1', 'category2'])
 	}
 
-	def IntrospectWithInheritedPropertyAnnotations() {
+	def 'should apply exclusion of ObjectDiffProperty annotation to accessor'() {
 		when:
-		  PropertyAwareAccessor accessor = introspector.introspect(ObjectWithInheritedPropertyAnnotation).first();
+		  def accessor = introspect(TypeWithPropertyAnnotation).get('value')
 		then:
-		  accessor.getElementSelector() == new BeanPropertyElementSelector("value")
-		  accessor.isExcluded()
+		  accessor.excluded == true
 	}
 
-	def IntrospectWithNullType() {
+	def 'should throw exception when invoked without type'() {
 		when:
-		  introspector.introspect(null);
+		  introspector.introspect(null)
 		then:
 		  thrown(IllegalArgumentException)
 	}
 
-	def IntrospectWithSimulatedIntrospectionException() {
+	def 'should skip default class properties'() {
+		expect:
+		  introspect(TypeWithNothingButDefaultProperties).isEmpty()
+	}
+
+	def 'should skip properties without getter'() {
+		expect:
+		  introspect(TypeWithPropertyWithoutGetter).isEmpty()
+	}
+
+	def 'should wrap IntrospectionException with RuntimeException'() {
 		given:
 		  introspector = new StandardBeanIntrospector() {
 			  @Override
@@ -128,4 +107,37 @@ public class StandardBeanIntrospectorTest extends Specification {
 		then:
 		  thrown(RuntimeException)
 	}
+
+	private class TypeWithNothingButDefaultProperties {
+	}
+
+	private class TypeWithPropertyWithoutGetter {
+		private String value
+
+		void setValue(String value) {
+			this.value = value
+		}
+	}
+
+	private class TypeWithPropertyAnnotation {
+		private String value
+
+		@ObjectDiffProperty(excluded = true, categories = ['category1', 'category2'])
+		String getValue() {
+			return value
+		}
+
+		void setValue(String value) {
+			this.value = value
+		}
+	}
+
+	private class TypeWithOnlyOneProperty {
+		def value
+	}
+
+	private class TypeWithTwoProperties {
+		def foo
+		def bar
+	}
 }