Test that DocumentField can handle maps and lists.

Author: jtibshirani

server/src/main/java/org/elasticsearch/common/document/DocumentField.java

@@ -113,10 +113,9 @@ public void writeTo(StreamOutput out) throws IOException {
     public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
         builder.startArray(name);
         for (Object value : values) {
-            // this call doesn't really need to support writing any kind of object.
-            // Stored fields values are converted using MappedFieldType#valueForDisplay.
-            // As a result they can either be Strings, Numbers, or Booleans, that's
-            // all.
+            // This call doesn't really need to support writing any kind of object, since the values
+            // here are always serializable to xContent. Each value could be a leaf types like a string,
+            // number, or boolean, a list of such values, or a map of such values with string keys.
             builder.value(value);
         }
         builder.endArray();

server/src/test/java/org/elasticsearch/index/get/DocumentFieldTests.java

@@ -38,6 +38,7 @@
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 import java.util.function.Supplier;
 
 import static org.elasticsearch.common.xcontent.XContentHelper.toXContent;
@@ -101,29 +102,43 @@ private static DocumentField mutateDocumentField(DocumentField documentField) {
     }
 
     public static Tuple<DocumentField, DocumentField> randomDocumentField(XContentType xContentType) {
-        if (randomBoolean()) {
-            String metaField = randomValueOtherThanMany(field -> field.equals(TypeFieldMapper.NAME)
-                    || field.equals(IndexFieldMapper.NAME) || field.equals(IdFieldMapper.NAME),
-                () -> randomFrom(MapperService.getAllMetaFields()));
-            DocumentField documentField;
-            if (metaField.equals(IgnoredFieldMapper.NAME)) {
-                int numValues = randomIntBetween(1, 3);
-                List<Object> ignoredFields = new ArrayList<>(numValues);
-                for (int i = 0; i < numValues; i++) {
-                    ignoredFields.add(randomAlphaOfLengthBetween(3, 10));
+        switch(randomIntBetween(0, 3)) {
+            case 0:
+                String metaField = randomValueOtherThanMany(field -> field.equals(TypeFieldMapper.NAME)
+                        || field.equals(IndexFieldMapper.NAME) || field.equals(IdFieldMapper.NAME),
+                    () -> randomFrom(MapperService.getAllMetaFields()));
+                DocumentField documentField;
+                if (metaField.equals(IgnoredFieldMapper.NAME)) {
+                    int numValues = randomIntBetween(1, 3);
+                    List<Object> ignoredFields = new ArrayList<>(numValues);
+                    for (int i = 0; i < numValues; i++) {
+                        ignoredFields.add(randomAlphaOfLengthBetween(3, 10));
+                    }
+                    documentField = new DocumentField(metaField, ignoredFields);
+                } else {
+                    //meta fields are single value only, besides _ignored
+                    documentField = new DocumentField(metaField, Collections.singletonList(randomAlphaOfLengthBetween(3, 10)));
                 }
-                documentField = new DocumentField(metaField, ignoredFields);
-            } else {
-                //meta fields are single value only, besides _ignored
-                documentField = new DocumentField(metaField, Collections.singletonList(randomAlphaOfLengthBetween(3, 10)));
-            }
-            return Tuple.tuple(documentField, documentField);
-        } else {
-            String fieldName = randomAlphaOfLengthBetween(3, 10);
-            Tuple<List<Object>, List<Object>> tuple = RandomObjects.randomStoredFieldValues(random(), xContentType);
-            DocumentField input = new DocumentField(fieldName, tuple.v1());
-            DocumentField expected = new DocumentField(fieldName, tuple.v2());
-            return Tuple.tuple(input, expected);
+                return Tuple.tuple(documentField, documentField);
+            case 1:
+                String fieldName = randomAlphaOfLengthBetween(3, 10);
+                Tuple<List<Object>, List<Object>> tuple = RandomObjects.randomStoredFieldValues(random(), xContentType);
+                DocumentField input = new DocumentField(fieldName, tuple.v1());
+                DocumentField expected = new DocumentField(fieldName, tuple.v2());
+                return Tuple.tuple(input, expected);
+            case 2:
+                List<Object> listValues = randomList(1, 5, () -> randomList(1, 5, ESTestCase::randomInt));
+                DocumentField listField = new DocumentField(randomAlphaOfLength(5), listValues);
+                return Tuple.tuple(listField, listField);
+            case 3:
+                List<Object> objectValues = randomList(1, 5, () ->
+                    Map.of(randomAlphaOfLength(5), randomInt(),
+                        randomAlphaOfLength(5), randomBoolean(),
+                        randomAlphaOfLength(5), randomAlphaOfLength(10)));
+                DocumentField objectField = new DocumentField(randomAlphaOfLength(5), objectValues);
+                return Tuple.tuple(objectField, objectField);
+            default:
+                throw new IllegalStateException();
         }
     }
 }

server/src/test/java/org/elasticsearch/search/SearchHitTests.java

@@ -188,7 +188,7 @@ public void testFromXContentLenientParsing() throws IOException {
         XContentType xContentType = randomFrom(XContentType.values());
         SearchHit searchHit = createTestItem(xContentType, true, true);
         BytesReference originalBytes = toXContent(searchHit, xContentType, true);
-        Predicate<String> pathsToExclude = path -> (path.endsWith("highlight") || path.endsWith("fields") || path.contains("_source")
+        Predicate<String> pathsToExclude = path -> (path.endsWith("highlight") || path.contains("fields") || path.contains("_source")
                 || path.contains("inner_hits"));
         BytesReference withRandomFields = insertRandomFields(xContentType, originalBytes, pathsToExclude, random());
 

server/src/test/java/org/elasticsearch/search/suggest/CompletionSuggestionOptionTests.java

@@ -87,7 +87,7 @@ private void doTestFromXContent(boolean addRandomFields) throws IOException {
             // also there can be inner search hits fields inside this option, we need to exclude another couple of paths
             // where we cannot add random stuff
             Predicate<String> excludeFilter = (path) -> (path.endsWith(CompletionSuggestion.Entry.Option.CONTEXTS.getPreferredName())
-                    || path.endsWith("highlight") || path.endsWith("fields") || path.contains("_source") || path.contains("inner_hits"));
+                    || path.endsWith("highlight") || path.contains("fields") || path.contains("_source") || path.contains("inner_hits"));
             mutated = insertRandomFields(xContentType, originalBytes, excludeFilter, random());
         } else {
             mutated = originalBytes;

server/src/test/java/org/elasticsearch/search/suggest/SuggestionEntryTests.java

@@ -104,7 +104,7 @@ private void doTestFromXContent(boolean addRandomFields) throws IOException {
                 // where we cannot add random stuff
                 Predicate<String> excludeFilter = (
                         path) -> (path.endsWith(CompletionSuggestion.Entry.Option.CONTEXTS.getPreferredName()) || path.endsWith("highlight")
-                                || path.endsWith("fields") || path.contains("_source") || path.contains("inner_hits"));
+                                || path.contains("fields") || path.contains("_source") || path.contains("inner_hits"));
                 mutated = insertRandomFields(xContentType, originalBytes, excludeFilter, random());
             } else {
                 mutated = originalBytes;

server/src/test/java/org/elasticsearch/search/suggest/SuggestionTests.java

@@ -124,7 +124,7 @@ private void doTestFromXContent(boolean addRandomFields) throws IOException {
                 // - the root object should be excluded since it contains the named suggestion arrays
                 Predicate<String> excludeFilter = path -> (path.isEmpty()
                         || path.endsWith(CompletionSuggestion.Entry.Option.CONTEXTS.getPreferredName()) || path.endsWith("highlight")
-                        || path.endsWith("fields") || path.contains("_source") || path.contains("inner_hits"));
+                        || path.contains("fields") || path.contains("_source") || path.contains("inner_hits"));
                 mutated = insertRandomFields(xContentType, originalBytes, excludeFilter, random());
             } else {
                 mutated = originalBytes;