Allow stricter type check on compared object and their fields

Author: joel-costigliola

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

@@ -14,6 +14,7 @@
 
 import static java.lang.String.format;
 import static java.lang.String.join;
+import static org.assertj.core.util.Lists.list;
 import static org.assertj.core.util.Objects.areEqual;
 
 import java.util.Collections;
@@ -50,6 +51,10 @@ public ComparisonDifference(List<String> path, Object actual, Object other, Stri
     this.additionalInformation = Optional.ofNullable(additionalInformation);
   }
 
+  public static ComparisonDifference rootComparisonDifference(Object actual, Object other, String additionalInformation) {
+    return new ComparisonDifference(list(""), actual, other, additionalInformation);
+  }
+
   public String getPath() {
     return concatenatedPath;
   }

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

@@ -43,9 +43,8 @@ public FieldComparators() {
    *
    * @param fieldLocation the FieldLocation where to apply the comparator
    * @param comparator the comparator it self
-   * @param <T> the type of the objects for the comparator
    */
-  public <T> void registerComparator(FieldLocation fieldLocation, Comparator<? super T> comparator) {
+  public void registerComparator(FieldLocation fieldLocation, Comparator<?> comparator) {
     fieldComparators.put(fieldLocation, comparator);
   }
 

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

@@ -38,7 +38,7 @@
 public class RecursiveComparisonConfiguration {
 
   public static final String INDENT_LEVEL_2 = "  -";
-  // private boolean strictTypeCheck = true;
+  private boolean strictTypeChecking = false;
 
   // fields to ignore section
   private boolean ignoreAllActualNullFields = false;
@@ -143,6 +143,14 @@ public void registerComparatorForField(FieldLocation fieldLocation, Comparator<?
     this.fieldComparators.registerComparator(fieldLocation, comparator);
   }
 
+  public boolean enforceStrictTypeChecking() {
+    return strictTypeChecking;
+  }
+
+  public void strictTypeChecking(boolean strictTypeChecking) {
+    this.strictTypeChecking = strictTypeChecking;
+  }
+
   @Override
   public String toString() {
     return multiLineDescription(CONFIGURATION_PROVIDER.representation());
@@ -156,6 +164,7 @@ public String multiLineDescription(Representation representation) {
     describeOverriddenEqualsMethodsUsage(description, representation);
     describeRegisteredComparatorByTypes(description);
     describeRegisteredComparatorForFields(description);
+    describeTypeCheckingStrictness(description);
     return description.toString();
   }
 
@@ -308,4 +317,11 @@ private String formatRegisteredComparatorForField(Entry<FieldLocation, Comparato
     return format("%s %s -> %s%n", INDENT_LEVEL_2, comparatorForField.getKey().getFieldPath(), comparatorForField.getValue());
   }
 
+  private void describeTypeCheckingStrictness(StringBuilder description) {
+    String str = strictTypeChecking
+        ? "- actual and expected objects and their fields were considered different when of incompatible types (i.e. expected type does not extend actual's type) even if all their fields match, for example a Person instance will never match a PersonDto (call strictTypeChecking(false) to change that behavior).%n"
+        : "- actual and expected objects and their fields were compared field by field recursively even if they were not of the same type, this allows for example to compare a Person to a PersonDto (call strictTypeChecking(true) to change that behavior).%n";
+    description.append(format(str));
+  }
+
 }

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

@@ -13,7 +13,9 @@
 package org.assertj.core.api.recursive.comparison;
 
 import static java.lang.String.format;
+import static org.assertj.core.api.recursive.comparison.ComparisonDifference.rootComparisonDifference;
 import static org.assertj.core.internal.Objects.getDeclaredFieldsIncludingInherited;
+import static org.assertj.core.util.Lists.list;
 import static org.assertj.core.util.Sets.newHashSet;
 import static org.assertj.core.util.introspection.PropertyOrFieldSupport.COMPARISON;
 
@@ -74,6 +76,9 @@ public class RecursiveComparisonDifferenceCalculator {
    */
   public static List<ComparisonDifference> determineDifferences(Object actual, Object expected,
                                                                 RecursiveComparisonConfiguration recursiveComparisonConfiguration) {
+    if (recursiveComparisonConfiguration.enforceStrictTypeChecking() && expectedTypeIsNotSubtypeOfActualType(actual, expected)) {
+      return list(expectedAndActualTypeDifference(actual, expected));
+    }
     return determineDifferences(actual, expected, null, recursiveComparisonConfiguration);
   }
 
@@ -102,7 +107,7 @@ private static List<ComparisonDifference> determineDifferences(Object actual, Ob
           // fields were not the same according to the custom comparator
           differences.add(new ComparisonDifference(currentPath, key1, key2));
         }
-        // since there was a custom comparator we don't need to inspect the fields
+        // since there was a custom comparator we don't need to inspect the nested fields further
         continue;
       }
 
@@ -155,7 +160,8 @@ private static List<ComparisonDifference> determineDifferences(Object actual, Ob
       // Handle all [] types. In order to be equal, the arrays must be the
       // same length, be of the same type, be in the same order, and all
       // elements within the array must be deeply equivalent.
-      if (key1.getClass().isArray()) {
+      Class<?> actualFieldClass = key1.getClass();
+      if (actualFieldClass.isArray()) {
         if (!compareArrays(key1, key2, currentPath, toCompare, visited)) {
           differences.add(new ComparisonDifference(currentPath, key1, key2));
           continue;
@@ -214,24 +220,32 @@ private static List<ComparisonDifference> determineDifferences(Object actual, Ob
       }
 
       if (!recursiveComparisonConfiguration.shouldIgnoreOverriddenEqualsOf(dualKey)
-          && hasCustomEquals(key1.getClass())) {
+          && hasCustomEquals(actualFieldClass)) {
         if (!key1.equals(key2)) {
           differences.add(new ComparisonDifference(currentPath, key1, key2));
           continue;
         }
         continue;
       }
 
-      Set<String> key1FieldsNames = getFieldsNames(getDeclaredFieldsIncludingInherited(key1.getClass()));
-      Set<String> key2FieldsNames = getFieldsNames(getDeclaredFieldsIncludingInherited(key2.getClass()));
+      Class<?> expectedFieldClass = key2.getClass();
+      if (recursiveComparisonConfiguration.enforceStrictTypeChecking() && expectedTypeIsNotSubtypeOfActualType(dualKey)) {
+        differences.add(new ComparisonDifference(currentPath, key1, key2,
+                                                 format("the fields are considered different since the comparison enforces strict type check and %s is not a subtype of %s",
+                                                        expectedFieldClass.getName(), actualFieldClass.getName())));
+        continue;
+      }
+
+      Set<String> key1FieldsNames = getFieldsNames(getDeclaredFieldsIncludingInherited(actualFieldClass));
+      Set<String> key2FieldsNames = getFieldsNames(getDeclaredFieldsIncludingInherited(expectedFieldClass));
       if (!key2FieldsNames.containsAll(key1FieldsNames)) {
         Set<String> key1FieldsNamesNotInKey2 = newHashSet(key1FieldsNames);
         key1FieldsNamesNotInKey2.removeAll(key2FieldsNames);
         String missingFields = key1FieldsNamesNotInKey2.toString();
-        String key2ClassName = key2.getClass().getName();
-        String key1ClassName = key1.getClass().getName();
-        String missingFieldsDescription = format(MISSING_FIELDS, key1ClassName, key2ClassName, key2.getClass().getSimpleName(),
-                                                 key1.getClass().getSimpleName(), missingFields);
+        String key2ClassName = expectedFieldClass.getName();
+        String key1ClassName = actualFieldClass.getName();
+        String missingFieldsDescription = format(MISSING_FIELDS, key1ClassName, key2ClassName, expectedFieldClass.getSimpleName(),
+                                                 actualFieldClass.getSimpleName(), missingFields);
         differences.add(new ComparisonDifference(currentPath, key1, key2, missingFieldsDescription));
       } else {
         for (String fieldName : key1FieldsNames) {
@@ -660,4 +674,18 @@ private static boolean propertyOrFieldValuesAreEqual(Object actualFieldValue, Ob
     return org.assertj.core.util.Objects.areEqual(actualFieldValue, otherFieldValue);
   }
 
+  private static ComparisonDifference expectedAndActualTypeDifference(Object actual, Object expected) {
+    String additionalInformation = format("actual and expected are considered different since the comparison enforces strict type check and expected type %s is not a subtype of actual type %s",
+                                          expected.getClass().getName(), actual.getClass().getName());
+    return rootComparisonDifference(actual, expected, additionalInformation);
+  }
+
+  private static boolean expectedTypeIsNotSubtypeOfActualType(DualKey dualField) {
+    return expectedTypeIsNotSubtypeOfActualType(dualField.key1, dualField.key2);
+  }
+
+  private static boolean expectedTypeIsNotSubtypeOfActualType(Object actual, Object expected) {
+    return !actual.getClass().isAssignableFrom(expected.getClass());
+  }
+
 }

src/test/java/org/assertj/core/api/recursive/comparison/RecursiveComparisonConfiguration_multiLineDescription_Test.java

@@ -138,6 +138,24 @@ public void should_show_the_registered_comparator_for_specific_fields_alphabetic
     // @format:on
   }
 
+  @Test
+  public void should_show_when_strict_type_checking_is_used() {
+    // WHEN
+    recursiveComparisonConfiguration.strictTypeChecking(true);
+    String multiLineDescription = recursiveComparisonConfiguration.multiLineDescription(STANDARD_REPRESENTATION);
+    // THEN
+    assertThat(multiLineDescription).contains(format("- actual and expected objects and their fields were considered different when of incompatible types (i.e. expected type does not extend actual's type) even if all their fields match, for example a Person instance will never match a PersonDto (call strictTypeChecking(false) to change that behavior).%n"));
+  }
+
+  @Test
+  public void should_show_when_lenient_type_checking_is_used() {
+    // WHEN
+    recursiveComparisonConfiguration.strictTypeChecking(false);
+    String multiLineDescription = recursiveComparisonConfiguration.multiLineDescription(STANDARD_REPRESENTATION);
+    // THEN
+    assertThat(multiLineDescription).contains(format("- actual and expected objects and their fields were compared field by field recursively even if they were not of the same type, this allows for example to compare a Person to a PersonDto (call strictTypeChecking(true) to change that behavior).%n"));
+  }
+
   @Test
   public void should_show_a_complete_multiline_description() {
     // GIVEN
@@ -171,7 +189,8 @@ public void should_show_a_complete_multiline_description() {
                "- these fields were compared with the following comparators:%n" +
                "  - bar.baz -> AlwaysDifferentComparator%n" +
                "  - foo -> AlwaysEqualComparator%n" +
-               "- field comparators take precedence over type comparators.%n"));
+               "- field comparators take precedence over type comparators.%n"+
+               "- actual and expected objects and their fields were compared field by field recursively even if they were not of the same type, this allows for example to compare a Person to a PersonDto (call strictTypeChecking(true) to change that behavior).%n"));
     // @format:on
   }
 

src/test/java/org/assertj/core/internal/objects/Objects_assertIsEqualToUsingRecursiveComparison_BaseTest.java

@@ -50,4 +50,8 @@ void areEqualsByRecursiveComparison(Object actual, Object expected,
   static ComparisonDifference diff(String path, Object actual, Object other) {
     return new ComparisonDifference(list(path), actual, other);
   }
+
+  static ComparisonDifference diff(String path, Object actual, Object other, String additionalInformation) {
+    return new ComparisonDifference(list(path), actual, other, additionalInformation);
+  }
 }

src/test/java/org/assertj/core/internal/objects/Objects_assertIsEqualToUsingRecursiveComparison_strictTypeCheck_Test.java

@@ -0,0 +1,161 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * Copyright 2012-2018 the original author or authors.
+ */
+package org.assertj.core.internal.objects;
+
+import static org.assertj.core.util.AssertionsUtil.expectAssertionError;
+
+import java.util.Date;
+
+import org.assertj.core.api.recursive.comparison.ComparisonDifference;
+import org.assertj.core.internal.objects.data.Giant;
+import org.assertj.core.internal.objects.data.Person;
+import org.assertj.core.internal.objects.data.PersonDto;
+import org.assertj.core.internal.objects.data.PersonDtoWithPersonNeighbour;
+import org.junit.jupiter.api.Test;
+
+public class Objects_assertIsEqualToUsingRecursiveComparison_strictTypeCheck_Test
+    extends Objects_assertIsEqualToUsingRecursiveComparison_BaseTest {
+
+  @Test
+  public void should_pass_by_default_when_objects_data_are_equals_whatever_their_types_are() {
+    // GIVEN
+    Person actual = new Person("John");
+    actual.home.address.number = 1;
+    actual.dateOfBirth = new Date(123);
+    actual.neighbour = new Person("Jack");
+    actual.neighbour.home.address.number = 123;
+    actual.neighbour.neighbour = new Person("James");
+    actual.neighbour.neighbour.home.address.number = 124;
+
+    PersonDto expected = new PersonDto("John");
+    expected.home.address.number = 1;
+    expected.dateOfBirth = new Date(123);
+    expected.neighbour = new PersonDto("Jack");
+    expected.neighbour.home.address.number = 123;
+    expected.neighbour.neighbour = new PersonDto("James");
+    expected.neighbour.neighbour.home.address.number = 124;
+
+    // THEN
+    areEqualsByRecursiveComparison(actual, expected, recursiveComparisonConfiguration);
+  }
+
+  @Test
+  public void should_pass_in_strict_type_check_mode_when_objects_data_are_equals_and_expected_type_is_compatible_with_actual_type() {
+    // GIVEN
+    Person actual = new Person("John");
+    actual.home.address.number = 1;
+    actual.dateOfBirth = new Date(123);
+    actual.neighbour = new Person("Jack");
+    actual.neighbour.home.address.number = 123;
+    actual.neighbour.neighbour = new Person("James");
+    actual.neighbour.neighbour.home.address.number = 124;
+
+    Giant expected = new Giant();
+    expected.name = "John";
+    expected.home.address.number = 1;
+    expected.dateOfBirth = new Date(123);
+    expected.neighbour = new Giant();
+    expected.neighbour.name = "Jack";
+    expected.neighbour.home.address.number = 123;
+    expected.neighbour.neighbour = new Person("James");
+    expected.neighbour.neighbour.home.address.number = 124;
+
+    Person expected2 = new Person("John");
+    expected2.home.address.number = 1;
+    expected2.dateOfBirth = new Date(123);
+    expected2.neighbour = new Person("Jack");
+    expected2.neighbour.home.address.number = 123;
+    expected2.neighbour.neighbour = new Person("James");
+    expected2.neighbour.neighbour.home.address.number = 124;
+
+    // WHEN
+    recursiveComparisonConfiguration.strictTypeChecking(true);
+
+    // THEN
+    areEqualsByRecursiveComparison(actual, expected, recursiveComparisonConfiguration);
+    areEqualsByRecursiveComparison(actual, expected2, recursiveComparisonConfiguration);
+  }
+
+  @Test
+  public void should_fail_in_strict_type_checking_mode_when_actual_and_expected_have_the_same_data_but_incompatible_types() {
+    // GIVEN
+    Person actual = new Person("John");
+    actual.home.address.number = 1;
+    actual.dateOfBirth = new Date(123);
+    actual.neighbour = new Person("Jack");
+    actual.neighbour.home.address.number = 123;
+
+    PersonDtoWithPersonNeighbour expected = new PersonDtoWithPersonNeighbour("John");
+    expected.home.address.number = 1;
+    expected.dateOfBirth = new Date(123);
+    expected.neighbour = new Person("Jack");
+    expected.neighbour.home.address.number = 123;
+
+    recursiveComparisonConfiguration.strictTypeChecking(true);
+
+    // WHEN
+    expectAssertionError(() -> areEqualsByRecursiveComparison(actual, expected, recursiveComparisonConfiguration));
+
+    // THEN
+    // as neighbour comparison fails, the comparison skip any neighbour fields
+    ComparisonDifference difference = diff("", actual, expected,
+                                           "actual and expected are considered different since the comparison enforces strict type check and expected type org.assertj.core.internal.objects.data.PersonDtoWithPersonNeighbour is not a subtype of actual type org.assertj.core.internal.objects.data.Person");
+    verifyShouldBeEqualByComparingFieldByFieldRecursivelyCall(actual, expected, difference);
+  }
+
+  @Test
+  public void should_fail_in_strict_type_checking_mode_when_actual_and_expected_fields_have_the_same_data_but_incompatible_types() {
+    // GIVEN
+    Something withA = new Something(new A(10));
+    Something withB = new Something(new B(10));
+
+    recursiveComparisonConfiguration.strictTypeChecking(true);
+
+    // WHEN
+    expectAssertionError(() -> areEqualsByRecursiveComparison(withA, withB, recursiveComparisonConfiguration));
+
+    // THEN
+    // inner comparison fails as the fields have different types
+    ComparisonDifference valueDifference = diff("inner", withA.inner, withB.inner,
+                                                "the fields are considered different since the comparison enforces strict type check and org.assertj.core.internal.objects.Objects_assertIsEqualToUsingRecursiveComparison_strictTypeCheck_Test$B is not a subtype of org.assertj.core.internal.objects.Objects_assertIsEqualToUsingRecursiveComparison_strictTypeCheck_Test$A");
+    verifyShouldBeEqualByComparingFieldByFieldRecursivelyCall(withA, withB, valueDifference);
+  }
+
+  private static class Something {
+    Inner inner;  // can be A or B
+
+    public Something(Inner inner) {
+      this.inner = inner;
+    }
+  }
+
+  private static class Inner {
+    @SuppressWarnings("unused")
+    int value;
+  }
+
+  private static class A extends Inner {
+
+    public A(int value) {
+      this.value = value;
+    }
+
+  }
+
+  private static class B extends Inner {
+    public B(int value) {
+      this.value = value;
+    }
+  }
+
+}