Add ignoreFieldsOfTypes to RecursiveComparisonConfiguration

Author: tommysitu

src/main/java/org/assertj/core/api/RecursiveComparisonAssert.java

@@ -208,7 +208,7 @@ public SELF ignoringActualNullFields() {
  }
 
  /**
- * Makes the recursive comparison to ignore the given the object under test fields. Nested fields can be specified like this: {@code home.address.street}.
+ * Makes the recursive comparison to ignore the given object under test fields. Nested fields can be specified like this: {@code home.address.street}.
  * <p>
  * Example:
  * <pre><code class='java'> public class Person {
@@ -302,6 +302,54 @@ public SELF ignoringFieldsMatchingRegexes(String... regexes) {
  return myself;
  }
 
+ /**
+ * Makes the recursive comparison to ignore the object under test fields of the given types.
+ * The fields are ignored if their types <b>exactly match one of the ignored types</b>, for example if a field is a subtype of an ignored type it is not ignored.
+ * <p>
+ * If some object under test fields are null it is not possible to evaluate their types unless in {@link #withStrictTypeChecking() strictTypeChecking mode},
+ * in that case the corresponding expected field's type is evaluated instead but if strictTypeChecking mode is disabled then null fields are not ignored.
+ * <p>
+ * Example:
+ * <pre><code class='java'> public class Person {
+ * String name;
+ * double height;
+ * Home home = new Home();
+ * }
+ *
+ * public class Home {
+ * Address address = new Address();
+ * }
+ *
+ * public static class Address {
+ * int number;
+ * String street;
+ * }
+ *
+ * Person sherlock = new Person("Sherlock", 1.80);
+ * sherlock.home.address.street = "Baker Street";
+ * sherlock.home.address.number = 221;
+ *
+ * Person sherlock2 = new Person("Sherlock", 1.90);
+ * sherlock2.home.address.street = "Butcher Street";
+ * sherlock2.home.address.number = 221;
+ *
+ * // assertion succeeds as we ignore Address and height
+ * assertThat(sherlock).usingRecursiveComparison()
+ * .ignoringFieldsOfTypes(double.class, Address.class)
+ * .isEqualTo(sherlock2);
+ *
+ * // now this assertion fails as expected since the home.address.street fields and height differ
+ * assertThat(sherlock).usingRecursiveComparison()
+ * .isEqualTo(sherlock2);</code></pre>
+ *
+ * @param typesToIgnore the types we want to ignore in the object under test fields.
+ * @return this {@link RecursiveComparisonAssert} to chain other methods.
+ */
+ public RecursiveComparisonAssert<?> ignoringFieldsOfTypes(Class<?>... typesToIgnore) {
+ recursiveComparisonConfiguration.ignoreFieldsOfTypes(typesToIgnore);
+ return myself;
+ }
+
  /**
  * By default the recursive comparison uses overridden {@code equals} methods to compare fields,
  * this method allows to compare recursively all fields <b>except fields with java types</b> (at some point we need to compare something!).

src/main/java/org/assertj/core/api/recursive/comparison/DualValue.java

@@ -16,6 +16,7 @@
 import static java.util.Collections.unmodifiableList;
 import static org.assertj.core.util.Arrays.array;
 import static org.assertj.core.util.Arrays.isArray;
+import static org.assertj.core.util.Lists.newArrayList;
 import static org.assertj.core.util.Strings.join;
 
 import java.util.LinkedHashSet;
@@ -39,7 +40,7 @@ final class DualValue {
 
 
  DualValue(List<String> path, Object actual, Object expected) {
- this.path = path;
+ this.path = newArrayList(path);
  this.concatenatedPath = join(path).with(".");
  this.actual = actual;
  this.expected = expected;
@@ -48,6 +49,10 @@ final class DualValue {
  hashCode = h1 + h2;
  }
 
+ DualValue(List<String> parentPath, String fieldName, Object actual, Object expected) {
+ this(fiedlPath(parentPath, fieldName), actual, expected);
+ }
+
  @Override
  public boolean equals(Object other) {
  if (!(other instanceof DualValue)) return false;
@@ -73,6 +78,11 @@ public String getConcatenatedPath() {
  return concatenatedPath;
  }
 
+ public String getFieldName() {
+ if (path.isEmpty()) return "";
+ return path.get(path.size() - 1);
+ }
+
  public boolean isJavaType() {
  if (actual == null) return false;
  return actual.getClass().getName().startsWith("java.");
@@ -153,4 +163,10 @@ private static boolean isContainer(Object o) {
  isArray(o);
  }
 
-}
+ private static List<String> fiedlPath(List<String> parentPath, String fieldName) {
+ List<String> fieldPath = newArrayList(parentPath);
+ fieldPath.add(fieldName);
+ return fieldPath;
+ }
+
+}

src/main/java/org/assertj/core/api/recursive/comparison/RecursiveComparisonConfiguration.java

@@ -13,23 +13,27 @@
 package org.assertj.core.api.recursive.comparison;
 
 import static java.lang.String.format;
+import static java.util.Arrays.stream;
 import static java.util.stream.Collectors.toList;
+import static java.util.stream.Collectors.toSet;
 import static org.assertj.core.configuration.ConfigurationProvider.CONFIGURATION_PROVIDER;
 import static org.assertj.core.internal.TypeComparators.defaultTypeComparators;
 import static org.assertj.core.util.Lists.list;
+import static org.assertj.core.util.Lists.newArrayList;
 import static org.assertj.core.util.Strings.join;
+import static org.assertj.core.util.introspection.PropertyOrFieldSupport.COMPARISON;
 
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map.Entry;
 import java.util.Set;
-import java.util.function.Predicate;
 import java.util.regex.Pattern;
 import java.util.stream.Stream;
 
 import org.assertj.core.api.RecursiveComparisonAssert;
+import org.assertj.core.internal.Objects;
 import org.assertj.core.internal.TypeComparators;
 import org.assertj.core.presentation.Representation;
 import org.assertj.core.util.VisibleForTesting;
@@ -43,6 +47,7 @@ public class RecursiveComparisonConfiguration {
  private boolean ignoreAllActualNullFields = false;
  private Set<FieldLocation> ignoredFields = new LinkedHashSet<>();
  private List<Pattern> ignoredFieldsRegexes = new ArrayList<>();
+ private Set<Class<?>> ignoredTypes = new LinkedHashSet<>();
 
  // overridden equals method to ignore section
  private List<Class<?>> ignoredOverriddenEqualsForTypes = new ArrayList<>();
@@ -132,6 +137,33 @@ public void ignoreFieldsMatchingRegexes(String... regexes) {
  .collect(toList()));
  }
 
+ /**
+ * Adds the given types to the list of the object under test fields types to ignore in the recursive comparison.
+ * The fields are ignored if their types exactly match one of the ignored types, if a field is a subtype of an ignored type it won't be ignored.
+ * <p>
+ * Note that if some object under test fields are null, they are not ignored by this method as their type can't be evaluated.
+ * <p>
+ * See {@link RecursiveComparisonAssert#ignoringFields(String...) RecursiveComparisonAssert#ignoringFields(String...)} for examples.
+ *
+ * @param types the types of the object under test to ignore in the comparison.
+ */
+ public void ignoreFieldsOfTypes(Class<?>... types) {
+ stream(types).map(type -> asWrapperIfPrimitiveType(type)).forEach(ignoredTypes::add);
+ }
+
+ private static Class<?> asWrapperIfPrimitiveType(Class<?> type) {
+ if (!type.isPrimitive()) return type;
+ if (type.equals(boolean.class)) return Boolean.class;
+ if (type.equals(byte.class)) return Byte.class;
+ if (type.equals(int.class)) return Integer.class;
+ if (type.equals(short.class)) return Short.class;
+ if (type.equals(char.class)) return Character.class;
+ if (type.equals(float.class)) return Float.class;
+ if (type.equals(double.class)) return Double.class;
+ // should not arrive here since we have tested primitive types first
+ return type;
+ }
+
  /**
  * Returns the list of the object under test fields to ignore in the recursive comparison.
  *
@@ -141,6 +173,15 @@ public Set<FieldLocation> getIgnoredFields() {
  return ignoredFields;
  }
 
+ /**
+ * Returns the set of the object under test fields types to ignore in the recursive comparison.
+ *
+ * @return the set of the object under test fields types to ignore in the recursive comparison.
+ */
+ public Set<Class<?>> getIgnoredTypes() {
+ return ignoredTypes;
+ }
+
  /**
  * Force a recursive comparison on all fields (except java types).
  * <p>
@@ -324,6 +365,7 @@ public String multiLineDescription(Representation representation) {
  describeIgnoreAllActualNullFields(description);
  describeIgnoredFields(description);
  describeIgnoredFieldsRegexes(description);
+ describeIgnoredFieldsForTypes(description);
  describeOverriddenEqualsMethodsUsage(description, representation);
  describeIgnoreCollectionOrder(description);
  describeIgnoredCollectionOrderInFields(description);
@@ -334,25 +376,58 @@ public String multiLineDescription(Representation representation) {
  return description.toString();
  }
 
- // non public stuff
-
- boolean shouldIgnore(DualValue dualKey) {
- return matchesAnIgnoredNullField(dualKey)
- || matchesAnIgnoredField(dualKey)
- || matchesAnIgnoredFieldRegex(dualKey);
+ boolean shouldIgnore(DualValue dualValue) {
+ String concatenatedPath = dualValue.concatenatedPath;
+ return matchesAnIgnoredField(concatenatedPath)
+ || matchesAnIgnoredFieldRegex(concatenatedPath)
+ || shouldIgnoreNotEvalutingFieldName(dualValue);
  }
 
- Predicate<String> shouldKeepField(String parentConcatenatedPath) {
- return fieldName -> shouldKeepField(parentConcatenatedPath, fieldName);
+ Set<String> getNonIgnoredActualFieldNames(DualValue dualValue) {
+ Set<String> actualFieldsNames = Objects.getFieldsNames(dualValue.actual.getClass());
+ // we are doing the same as shouldIgnore(DualValue dualKey) but in two steps for performance reasons:
+ // - we filter first ignored field by names that don't need building DualValues
+ // - then we filter field DualValues with the remaining criteria (shouldIgnoreNotEvalutingFieldName)
+ // DualValuea are built introspecting fields which is expensive.
+ return actualFieldsNames.stream()
+ // evaluate field name ignoring criteria
+ .filter(fieldName -> !shouldIgnore(dualValue.path, fieldName))
+ .map(fieldName -> dualValueForField(dualValue, fieldName))
+ // evaluate field value ignoring criteria
+ .filter(fieldDualValue -> !shouldIgnoreNotEvalutingFieldName(fieldDualValue))
+ // back to field name
+ .map(DualValue::getFieldName)
+ .filter(fieldName -> !fieldName.isEmpty())
+ .collect(toSet());
  }
 
- private boolean shouldKeepField(String parentPath, String fieldName) {
- String fieldConcatenatedPath = concatenatedPath(parentPath, fieldName);
- return !matchesAnIgnoredField(fieldConcatenatedPath) && !matchesAnIgnoredFieldRegex(fieldConcatenatedPath);
- }
+ // non public stuff
 
- private static String concatenatedPath(String parentPath, String name) {
- return parentPath.isEmpty() ? name : format("%s.%s", parentPath, name);
+ private boolean shouldIgnoreNotEvalutingFieldName(DualValue dualKey) {
+ return matchesAnIgnoredNullField(dualKey) || matchesAnIgnoredFieldType(dualKey);
+ }
+
+ private boolean shouldIgnore(List<String> parentConcatenatedPath, String fieldName) {
+ List<String> fieldConcatenatedPathList = newArrayList(parentConcatenatedPath);
+ fieldConcatenatedPathList.add(fieldName);
+ String fieldConcatenatedPath = join(fieldConcatenatedPathList).with(".");
+ return matchesAnIgnoredField(fieldConcatenatedPath) || matchesAnIgnoredFieldRegex(fieldConcatenatedPath);
+ }
+
+ private static DualValue dualValueForField(DualValue parentDualValue, String fieldName) {
+ List<String> path = newArrayList(parentDualValue.path);
+ path.add(fieldName);
+ Object actualFieldValue = COMPARISON.getSimpleValue(fieldName, parentDualValue.actual);
+ // no guarantees we have a field in expected named as fieldName
+ Object expectedFieldValue;
+ try {
+ expectedFieldValue = COMPARISON.getSimpleValue(fieldName, parentDualValue.expected);
+ } catch (@SuppressWarnings("unused") Exception e) {
+ // set the field to null to express it is absent, this not 100% accurate as the value could be null
+ // but it works to evaluate if dualValue should be ignored with matchesAnIgnoredFieldType
+ expectedFieldValue = null;
+ }
+ return new DualValue(path, actualFieldValue, expectedFieldValue);
  }
 
  boolean hasCustomComparator(DualValue dualValue) {
@@ -393,6 +468,11 @@ private void describeIgnoredFields(StringBuilder description) {
  description.append(format("- the following fields were ignored in the comparison: %s%n", describeIgnoredFields()));
  }
 
+ private void describeIgnoredFieldsForTypes(StringBuilder description) {
+ if (!ignoredTypes.isEmpty())
+ description.append(format("- the following types were ignored in the comparison: %s%n", describeIgnoredTypes()));
+ }
+
  private void describeIgnoreAllActualNullFields(StringBuilder description) {
  if (ignoreAllActualNullFields) description.append(format("- all actual null fields were ignored in the comparison%n"));
  }
@@ -469,21 +549,24 @@ private boolean matchesAnIgnoredOverriddenEqualsField(DualValue dualKey) {
  .anyMatch(fieldLocation -> fieldLocation.matches(dualKey.concatenatedPath));
  }
 
- private boolean matchesAnIgnoredNullField(DualValue dualKey) {
- return ignoreAllActualNullFields && dualKey.actual == null;
+ private boolean matchesAnIgnoredNullField(DualValue dualValue) {
+ return ignoreAllActualNullFields && dualValue.actual == null;
  }
 
  private boolean matchesAnIgnoredFieldRegex(String fieldConcatenatedPath) {
  return ignoredFieldsRegexes.stream()
  .anyMatch(regex -> regex.matcher(fieldConcatenatedPath).matches());
  }
 
- private boolean matchesAnIgnoredFieldRegex(DualValue dualKey) {
- return matchesAnIgnoredFieldRegex(dualKey.concatenatedPath);
- }
-
- private boolean matchesAnIgnoredField(DualValue dualKey) {
- return matchesAnIgnoredField(dualKey.concatenatedPath);
+ private boolean matchesAnIgnoredFieldType(DualValue dualKey) {
+ Object actual = dualKey.actual;
+ if (actual != null) return ignoredTypes.contains(actual.getClass());
+ Object expected = dualKey.expected;
+ // actual is null => we can't evaluate its type, we can only reliably check dualKey.expected's type if
+ // strictTypeChecking is enabled which guarantees expected is of the same type.
+ if (strictTypeChecking && expected != null) return ignoredTypes.contains(expected.getClass());
+ // if strictTypeChecking is disabled, we can't safely ignore the field (if we did, we would ignore all null fields!).
+ return false;
  }
 
  private boolean matchesAnIgnoredField(String fieldConcatenatedPath) {
@@ -508,6 +591,13 @@ private String describeIgnoredFields() {
  return join(fieldsDescription).with(", ");
  }
 
+ private String describeIgnoredTypes() {
+ List<String> typesDescription = ignoredTypes.stream()
+ .map(Class::getName)
+ .collect(toList());
+ return join(typesDescription).with(", ");
+ }
+
  private String describeIgnoredCollectionOrderInFields() {
  List<String> fieldsDescription = ignoredCollectionOrderInFields.stream()
  .map(FieldLocation::getFieldPath)