Fix #1161 map assertion extracting should extract values from Object …

…keys and not be limited to String keys
assertj · Mar 11, 2018 · 44faac9 · 44faac9
1 parent c71c045
commit 44faac9
Show file tree

Hide file tree

Showing 3 changed files with 49 additions and 35 deletions.
diff --git a/src/main/java/org/assertj/core/api/AbstractMapAssert.java b/src/main/java/org/assertj/core/api/AbstractMapAssert.java
@@ -19,19 +19,21 @@
 import static org.assertj.core.util.Arrays.array;
 import static org.assertj.core.util.Arrays.isArray;
 import static org.assertj.core.util.IterableUtil.toCollection;
+import static org.assertj.core.util.Preconditions.checkNotNull;
 
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
 import java.util.function.BiConsumer;
 import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import org.assertj.core.description.Description;
 import org.assertj.core.groups.Tuple;
 import org.assertj.core.internal.Maps;
 import org.assertj.core.util.CheckReturnValue;
-import org.assertj.core.util.Preconditions;
 import org.assertj.core.util.VisibleForTesting;
 
 /**
@@ -1200,7 +1202,7 @@ public SELF withThreadDumpOnError() {
   @SuppressWarnings({ "rawtypes", "unchecked" })
   @CheckReturnValue
   public AbstractMapSizeAssert<SELF, ACTUAL, K, V> size() {
-    Preconditions.checkNotNull(actual, "Can not perform assertions on the size of a null map.");
+    checkNotNull(actual, "Can not perform assertions on the size of a null map.");
     return new MapSizeAssert(this, actual.size());
   }
 
@@ -1230,9 +1232,12 @@ public AbstractMapSizeAssert<SELF, ACTUAL, K, V> size() {
    * @return a new assertion object whose object under test is the array containing the extracted map values
    */
   @CheckReturnValue
-  @Override
-  public AbstractListAssert<?, List<? extends Object>, Object, ObjectAssert<Object>> extracting(String... keys) {
-    return super.extracting(keys);
+  public AbstractListAssert<?, List<? extends Object>, Object, ObjectAssert<Object>> extracting(Object... keys) {
+    isNotNull();
+    List<Object> extractedValues = Stream.of(keys).map(actual::get).collect(Collectors.toList());
+    String extractedPropertiesOrFieldsDescription = extractedDescriptionOf(keys);
+    String description = mostRelevantDescription(info.description(), extractedPropertiesOrFieldsDescription);
+    return newListAssertInstance(extractedValues).as(description);
   }
 
   /**

diff --git a/src/main/java/org/assertj/core/extractor/Extractors.java b/src/main/java/org/assertj/core/extractor/Extractors.java
@@ -14,6 +14,8 @@
 
 import static java.lang.String.format;
 
+import java.util.stream.Stream;
+
 import org.assertj.core.api.iterable.Extractor;
 import org.assertj.core.groups.Tuple;
 import org.assertj.core.util.Strings;
@@ -68,8 +70,13 @@ public static <F> Extractor<F, Object> resultOf(String methodName) {
     return new ResultOfExtractor<>(methodName);
   }
 
-  public static String extractedDescriptionOf(String... propertiesOrFields) {
-    return format("Extracted: %s", Strings.join(propertiesOrFields).with(", "));
+  public static String extractedDescriptionOf(String... itemsDescription) {
+    return format("Extracted: %s", Strings.join(itemsDescription).with(", "));
+  }
+
+  public static String extractedDescriptionOf(Object... items) {
+    String[] itemsDescription = Stream.of(items).map(Object::toString).toArray(String[]::new);
+    return extractedDescriptionOf(itemsDescription);
   }
 
   public static String extractedDescriptionOfMethod(String method) {

diff --git a/src/test/java/org/assertj/core/api/map/MapAssert_extracting_Test.java b/src/test/java/org/assertj/core/api/map/MapAssert_extracting_Test.java
@@ -13,72 +13,74 @@
 package org.assertj.core.api.map;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.catchThrowable;
 import static org.assertj.core.test.ExpectedException.none;
+import static org.assertj.core.util.FailureMessages.actualIsNull;
 
 import java.util.HashMap;
 import java.util.Map;
 
 import org.assertj.core.test.ExpectedException;
+import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 
 public class MapAssert_extracting_Test {
 
+  private static final Object NAME = "name";
+
   @Rule
   public ExpectedException thrown = none();
 
-  @Test
-  public void should_allow_assertions_on_values_extracted_from_given_map_keys() {
-    Map<String, Object> map = new HashMap<>();
-    map.put("name", "kawhi");
-    map.put("age", 25);
+  private Map<Object, Object> map;
 
-    assertThat(map).extracting("name", "age")
-                   .contains("kawhi", 25);
+  @Before
+  public void setup() {
+    map = new HashMap<>();
+    map.put(NAME, "kawhi");
+    map.put("age", 25);
+  }
 
-    assertThat(map).extracting(m -> m.get("name"), m -> m.get("age"))
+  @Test
+  public void should_allow_assertions_on_values_extracted_from_given_map_keys() {
+    assertThat(map).extracting(NAME, "age")
                    .contains("kawhi", 25);
   }
 
   @Test
   public void should_allow_assertions_on_values_extracted_from_given_extractors() {
-    Map<String, Object> map = new HashMap<>();
-    map.put("name", "kawhi");
-    map.put("age", 25);
-
-    assertThat(map).extracting(m -> m.get("name"), m -> m.get("age"))
+    assertThat(map).extracting(m -> m.get(NAME), m -> m.get("age"))
                    .contains("kawhi", 25);
   }
 
   @Test
   public void should_extract_null_from_unknown_key() {
-    Map<String, Object> map = new HashMap<>();
-    map.put("name", "kawhi");
-    map.put("age", 25);
-
-    assertThat(map).extracting("name", "id")
+    assertThat(map).extracting(NAME, "id")
                    .contains("kawhi", (Object) null);
   }
 
   @Test
   public void should_use_key_names_as_description() {
-    Map<String, Object> map = new HashMap<>();
-    map.put("name", "kawhi");
-    map.put("age", 25);
-
     thrown.expectAssertionErrorWithMessageContaining("[Extracted: name, age]");
 
-    assertThat(map).extracting("name", "age").isEmpty();
+    assertThat(map).extracting(NAME, "age").isEmpty();
   }
 
   @Test
   public void should_keep_existing_description_if_set_when_extracting_values_list() {
-    Map<String, Object> map = new HashMap<>();
-    map.put("name", "kawhi");
-    map.put("age", 25);
-
     thrown.expectAssertionErrorWithMessageContaining("[check name and age]");
 
-    assertThat(map).as("check name and age").extracting("name", "age").isEmpty();
+    assertThat(map).as("check name and age").extracting(NAME, "age").isEmpty();
   }
+
+  @Test
+  public void should_fail_if_actual_is_null() {
+    // GIVEN
+    map = null;
+    // WHEN
+    Throwable error = catchThrowable(() -> assertThat(map).extracting(NAME, "age"));
+    // THEN
+    assertThat(error).hasMessage(actualIsNull());
+  }
+
 }