Add support for assumptions

Author: joel-costigliola

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/test/java/org/assertj/core/api/recursive/comparison/RecursiveComparisonAssert_assumptions_Test.java

@@ -0,0 +1,64 @@
+/*
+ * 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.api.recursive.comparison;
+
+import static org.assertj.core.api.Assertions.assertThatCode;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.assertj.core.api.Assumptions.assumeThat;
+import static org.assertj.core.presentation.UnicodeRepresentation.UNICODE_REPRESENTATION;
+
+import org.assertj.core.api.RecursiveComparisonAssert_isEqualTo_BaseTest;
+import org.assertj.core.internal.objects.data.Person;
+import org.junit.AssumptionViolatedException;
+import org.junit.jupiter.api.Test;
+
+public class RecursiveComparisonAssert_assumptions_Test extends RecursiveComparisonAssert_isEqualTo_BaseTest {
+
+  @Test
+  public void should_ignore_test_when_one_of_the_assumption_fails() {
+    // GIVEN
+    Person actual = new Person("John");
+    actual.home.address.number = 1;
+    Person expected = new Person("John");
+    expected.home.address.number = 1;
+    Person unexpected = new Person("John");
+    unexpected.home.address.number = 2;
+    // THEN
+    assumeThat(actual).usingRecursiveComparison().isEqualTo(expected);
+    assertThatExceptionOfType(AssumptionViolatedException.class).isThrownBy(() -> assumeThat(actual).usingRecursiveComparison()
+                                                                                                    .isEqualTo(unexpected));
+  }
+
+  @Test
+  public void should_run_test_when_all_assumptions_are_met() {
+    // GIVEN
+    Person actual = new Person("John");
+    actual.home.address.number = 1;
+    Person expected = new Person("John");
+    expected.home.address.number = 1;
+    // THEN
+    assertThatCode(() -> {
+      assumeThat("foo").isNotNull()
+                       .isNotEmpty()
+                       .isEqualTo("foo");
+      assumeThat(actual).usingRecursiveComparison().isEqualTo(expected);
+      assumeThat(expected).usingRecursiveComparison().isEqualTo(actual);
+      assumeThat(actual).as("test description")
+                        .withFailMessage("error message")
+                        .withRepresentation(UNICODE_REPRESENTATION)
+                        .usingRecursiveComparison()
+                        .isEqualTo(expected);
+    }).doesNotThrowAnyException();
+  }
+
+}