Merge branch 'recursive-api'

Author: joel-costigliola

pom.xml

@@ -105,6 +105,12 @@
       <version>25.0-jre</version>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>org.apache.commons</groupId>
+      <artifactId>commons-lang3</artifactId>
+      <version>3.8.1</version>
+      <scope>test</scope>
+    </dependency>
   </dependencies>
   <build>
     <plugins>
@@ -217,6 +223,13 @@
           </execution>
         </executions>
       </plugin>
+      <plugin>
+        <artifactId>maven-javadoc-plugin</artifactId>
+        <configuration>
+          <!-- some jdk don't support nested li tags :( -->
+          <doclint>none</doclint>
+        </configuration>
+      </plugin>
       <!-- generate jacoco report -->
       <plugin>
         <groupId>org.jacoco</groupId>
@@ -329,7 +342,8 @@
       </activation>
       <properties>
         <sonar.skip>true</sonar.skip>
-        <!-- currently fails with "javadoc: error - The code being documented uses modules but the packages defined in https://docs.oracle.com/javase/8/docs/api/ are in the unnamed module." -->
+        <!-- currently fails with "javadoc: error - The code being documented uses modules but the packages defined in https://docs.oracle.com/javase/8/docs/api/
+          are in the unnamed module." -->
         <maven.javadoc.skip>true</maven.javadoc.skip>
       </properties>
     </profile>

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

@@ -66,13 +66,14 @@ public abstract class AbstractAssert<SELF extends AbstractAssert<SELF, ACTUAL>,
   Conditions conditions = Conditions.instance();
 
   @VisibleForTesting
-  public final WritableAssertionInfo info;
+  public WritableAssertionInfo info;
 
   // visibility is protected to allow us write custom assertions that need access to actual
   @VisibleForTesting
   protected final ACTUAL actual;
   protected final SELF myself;
 
+  // = ConfigurationProvider.CONFIGURATION_PROVIDER.representation(); ?
   private static Representation customRepresentation = null;
 
   @VisibleForTesting
@@ -675,9 +676,9 @@ public SELF satisfies(Consumer<ACTUAL> requirements) {
    * <p>
    * This allows users to perform <b>OR like assertions</b> since only one the assertions group has to be met.
    * <p>
-   * {@link #overridingErrorMessage(String, Object...) Overriding error message} is not supported as it would prevent from 
+   * {@link #overridingErrorMessage(String, Object...) Overriding error message} is not supported as it would prevent from
    * getting the error messages of the failing assertions, these are valuable to figure out what went wrong.<br>
-   * Describing the assertion is supported (for example with {@link #as(String, Object...)}). 
+   * Describing the assertion is supported (for example with {@link #as(String, Object...)}).
    * <p>
    * Example:
    * <pre><code class='java'> TolkienCharacter frodo = new TolkienCharacter("Frodo", HOBBIT);
@@ -710,9 +711,9 @@ public SELF satisfiesAnyOf(Consumer<ACTUAL> assertions1, Consumer<ACTUAL> assert
    * <p>
    * This allows users to perform <b>OR like assertions</b> since only one the assertions group has to be met.
    * <p>
-   * {@link #overridingErrorMessage(String, Object...) Overriding error message} is not supported as it would prevent from 
+   * {@link #overridingErrorMessage(String, Object...) Overriding error message} is not supported as it would prevent from
    * getting the error messages of the failing assertions, these are valuable to figure out what went wrong.<br>
-   * Describing the assertion is supported (for example with {@link #as(String, Object...)}). 
+   * Describing the assertion is supported (for example with {@link #as(String, Object...)}).
    * <p>
    * Example:
    * <pre><code class='java'> TolkienCharacter frodo = new TolkienCharacter("Frodo", HOBBIT);

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

@@ -26,6 +26,8 @@
 import java.util.function.Function;
 import java.util.stream.Stream;
 
+import org.assertj.core.annotations.Beta;
+import org.assertj.core.api.recursive.comparison.RecursiveComparisonConfiguration;
 import org.assertj.core.description.Description;
 import org.assertj.core.groups.Tuple;
 import org.assertj.core.internal.TypeComparators;
@@ -672,7 +674,7 @@ public AbstractListAssert<?, List<? extends Object>, Object, ObjectAssert<Object
   }
 
   /**
-   * Asserts that the object under test (actual) is equal to the given object based on recursive a property/field by property/field comparison (including
+   * Asserts that the object under test (actual) is equal to the given object based on a recursive property/field by property/field comparison (including
    * inherited ones). This can be useful if actual's {@code equals} implementation does not suit you.
    * The recursive property/field comparison is <b>not</b> applied on fields having a custom {@code equals} implementation, i.e.
    * the overridden {@code equals} method will be used instead of a field by field comparison.
@@ -770,6 +772,74 @@ public <T> SELF returns(T expected, Function<ACTUAL, T> from) {
     return myself;
   }
 
+  /**
+   * Enable using a recursive field by field comparison strategy when calling the chained {@link RecursiveComparisonAssert#isEqualTo(Object) isEqualTo} assertion.
+   * <p>
+   * Example:
+   * <pre><code class='java'> public class Person {
+   *   String name;
+   *   double height;
+   *   Home home = new Home();
+   * }
+   *
+   * public class Home {
+   *   Address address = new Address();
+   *   Date ownedSince;
+   * }
+   *
+   * public static class Address {
+   *   int number;
+   *   String street;
+   * }
+   *
+   * Person sherlock = new Person("Sherlock", 1.80);
+   * sherlock.home.ownedSince = new Date(123);
+   * sherlock.home.address.street = "Baker Street";
+   * sherlock.home.address.number = 221;
+   *
+   * Person sherlock2 = new Person("Sherlock", 1.80);
+   * sherlock2.home.ownedSince = new Date(123);
+   * sherlock2.home.address.street = "Baker Street";
+   * sherlock2.home.address.number = 221;
+   *
+   * // assertion succeeds as the data of both objects are the same.
+   * assertThat(sherlock).usingRecursiveComparison()
+   *                     .isEqualTo(sherlock2);
+   *
+   * // assertion fails because sherlock.equals(sherlock2) is false.
+   * assertThat(sherlock).isEqualTo(sherlock2);</code></pre>
+   * <p>
+   * The recursive comparison is performed according to the default {@link RecursiveComparisonConfiguration} that is:
+   * <ul>
+   * <li>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 {@link RecursiveComparisonAssert#withStrictTypeChecking() withStrictTypeChecking()} to change that behavior). </li>
+   * <li>overridden equals methods were used in the comparison (unless stated otherwise)</li>
+   * <li>these types were compared with the following comparators: </li>
+   *   <ul>
+   *   <li>java.lang.Double -&gt; DoubleComparator[precision=1.0E-15] </li>
+   *   <li>java.lang.Float -&gt; FloatComparator[precision=1.0E-6] </li>
+   *   <li>any comparators previously registered with {@link AbstractObjectAssert#usingComparatorForType(Comparator, Class)} </li>
+   *   </ul>
+   * </ul>
+   *
+   * @return a new {@link RecursiveComparisonAssert} instance
+   */
+  @Beta
+  public RecursiveComparisonAssert<?> usingRecursiveComparison() {
+    return usingRecursiveComparison(new RecursiveComparisonConfiguration());
+  }
+
+  /**
+   * Same as {@link #usingRecursiveComparison()} but allows to specify your own {@link RecursiveComparisonConfiguration}.
+   * @param recursiveComparisonConfiguration the {@link RecursiveComparisonConfiguration} used in the chained {@link RecursiveComparisonAssert#isEqualTo(Object) isEqualTo} assertion.
+   *
+   * @return a new {@link RecursiveComparisonAssert} instance built with the given {@link RecursiveComparisonConfiguration}.
+   */
+  @Beta
+  public RecursiveComparisonAssert<?> usingRecursiveComparison(RecursiveComparisonConfiguration recursiveComparisonConfiguration) {
+    return new RecursiveComparisonAssert<>(actual, recursiveComparisonConfiguration).withAssertionState(myself)
+                                                                                    .withTypeComparators(comparatorByType);
+  }
+
   // override for proxyable friendly AbstractObjectAssert
   protected AbstractObjectAssert<?, ?> newObjectAssert(Object objectUnderTest) {
     return new ObjectAssert<>(objectUnderTest);

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

@@ -67,6 +67,7 @@
 import java.util.stream.Stream;
 
 import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
+import org.assertj.core.api.recursive.comparison.RecursiveComparisonConfiguration;
 import org.assertj.core.util.CheckReturnValue;
 
 import net.bytebuddy.ByteBuddy;
@@ -1181,11 +1182,19 @@ private static RuntimeException assumptionNotMet(Class<?> exceptionClass,
     if (assertion instanceof MapSizeAssert) return asMapSizeAssumption(assertion);
     if (assertion instanceof ProxyableObjectAssert) return asAssumption(ObjectAssert.class, Object.class, actual);
     if (assertion instanceof ObjectAssert) return asAssumption(ObjectAssert.class, Object.class, actual);
+    if (assertion instanceof RecursiveComparisonAssert) return asRecursiveComparisonAssumption(assertion);
     // @format:on
     // should not arrive here
     throw new IllegalArgumentException("Unsupported assumption creation for " + assertion.getClass());
   }
 
+  private static AbstractAssert<?, ?> asRecursiveComparisonAssumption(AbstractAssert<?, ?> assertion) {
+    RecursiveComparisonAssert<?> recursiveComparisonAssert = (RecursiveComparisonAssert<?>) assertion;
+    RecursiveComparisonConfiguration recursiveComparisonConfiguration = recursiveComparisonAssert.getRecursiveComparisonConfiguration();
+    Class<?>[] constructorTypes = array(Object.class, RecursiveComparisonConfiguration.class);
+    return asAssumption(RecursiveComparisonAssert.class, constructorTypes, assertion.actual, recursiveComparisonConfiguration);
+  }
+
   private static AbstractAssert<?, ?> asMapSizeAssumption(AbstractAssert<?, ?> assertion) {
     MapSizeAssert<?, ?> mapSizeAssert = (MapSizeAssert<?, ?>) assertion;
     Class<?>[] constructorTypes = array(AbstractMapAssert.class, Integer.class);

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

@@ -50,7 +50,14 @@ public class ProxifyMethodChangingTheObjectUnderTest {
   private AbstractAssert createAssertProxy(Object currentActual) {
     if (currentActual instanceof IterableSizeAssert) return createIterableSizeAssertProxy(currentActual);
     if (currentActual instanceof MapSizeAssert) return createMapSizeAssertProxy(currentActual);
-    return (AbstractAssert) proxies.createSoftAssertionProxy(currentActual.getClass(), actualClass(currentActual), actual(currentActual));
+    if (currentActual instanceof RecursiveComparisonAssert)
+      return createRecursiveComparisonAssertProxy((RecursiveComparisonAssert) currentActual);
+    return (AbstractAssert) proxies.createSoftAssertionProxy(currentActual.getClass(), actualClass(currentActual),
+                                                             actual(currentActual));
+  }
+
+  private RecursiveComparisonAssert<?> createRecursiveComparisonAssertProxy(RecursiveComparisonAssert<?> currentAssert) {
+    return proxies.createRecursiveComparisonAssertProxy(currentAssert);
   }
 
   private MapSizeAssert<?, ?> createMapSizeAssertProxy(Object currentActual) {
@@ -72,6 +79,7 @@ private static Class actualClass(Object result) {
     if (result instanceof ObjectAssert || result instanceof ProxyableObjectAssert) return Object.class;
     if (result instanceof MapAssert) return Map.class;
     if (result instanceof StringAssert) return String.class;
+    if (result instanceof RecursiveComparisonAssert) return Object.class;
     // Trying to create a proxy will only match exact constructor argument types.
     // To initialize one for ListAssert for example we can't use an ArrayList, we have to use a List.
     // So we can't just return actual.getClass() as we could read a concrete class whereas