Add random tests with match_only_text multi-field

test/framework/src/main/java/org/elasticsearch/datageneration/FieldType.java

@@ -23,6 +23,7 @@
 import org.elasticsearch.datageneration.fields.leaf.IpFieldDataGenerator;
 import org.elasticsearch.datageneration.fields.leaf.KeywordFieldDataGenerator;
 import org.elasticsearch.datageneration.fields.leaf.LongFieldDataGenerator;
+import org.elasticsearch.datageneration.fields.leaf.MatchOnlyTextFieldDataGenerator;
 import org.elasticsearch.datageneration.fields.leaf.ScaledFloatFieldDataGenerator;
 import org.elasticsearch.datageneration.fields.leaf.ShortFieldDataGenerator;
 import org.elasticsearch.datageneration.fields.leaf.TextFieldDataGenerator;
@@ -50,7 +51,8 @@ public enum FieldType {
     TEXT("text"),
     IP("ip"),
     CONSTANT_KEYWORD("constant_keyword"),
-    WILDCARD("wildcard");
+    WILDCARD("wildcard"),
+    MATCH_ONLY_TEXT("match_only_text");
 
     private final String name;
 
@@ -78,6 +80,7 @@ public FieldDataGenerator generator(String fieldName, DataSource dataSource) {
             case IP -> new IpFieldDataGenerator(dataSource);
             case CONSTANT_KEYWORD -> new ConstantKeywordFieldDataGenerator();
             case WILDCARD -> new WildcardFieldDataGenerator(dataSource);
+            case MATCH_ONLY_TEXT -> new MatchOnlyTextFieldDataGenerator(dataSource);
         };
     }
 
@@ -101,6 +104,7 @@ public static FieldType tryParse(String name) {
             case "ip" -> FieldType.IP;
             case "constant_keyword" -> FieldType.CONSTANT_KEYWORD;
             case "wildcard" -> FieldType.WILDCARD;
+            case "match_only_text" -> FieldType.MATCH_ONLY_TEXT;
             default -> null;
         };
     }

test/framework/src/main/java/org/elasticsearch/datageneration/datasource/DefaultMappingParametersHandler.java

@@ -22,6 +22,7 @@
 import java.time.ZoneOffset;
 import java.time.format.DateTimeFormatter;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.function.Supplier;
@@ -37,17 +38,18 @@ public DataSourceResponse.LeafMappingParametersGenerator handle(DataSourceReques
         }
 
         return new DataSourceResponse.LeafMappingParametersGenerator(switch (fieldType) {
-            case KEYWORD -> keywordMapping(request);
+            case KEYWORD -> keywordMapping(false, request);
             case LONG, INTEGER, SHORT, BYTE, DOUBLE, FLOAT, HALF_FLOAT, UNSIGNED_LONG -> numberMapping(fieldType);
             case SCALED_FLOAT -> scaledFloatMapping();
             case COUNTED_KEYWORD -> countedKeywordMapping();
             case BOOLEAN -> booleanMapping();
             case DATE -> dateMapping();
             case GEO_POINT -> geoPointMapping();
-            case TEXT -> textMapping(request);
+            case TEXT -> textMapping(false, request);
             case IP -> ipMapping();
             case CONSTANT_KEYWORD -> constantKeywordMapping();
-            case WILDCARD -> wildcardMapping();
+            case WILDCARD -> wildcardMapping(false, request);
+            case MATCH_ONLY_TEXT -> matchOnlyTextMapping(false, request);
         });
     }
 
@@ -77,7 +79,7 @@ private Supplier<Map<String, Object>> numberMapping(FieldType fieldType) {
         };
     }
 
-    private Supplier<Map<String, Object>> keywordMapping(DataSourceRequest.LeafMappingParametersGenerator request) {
+    private Supplier<Map<String, Object>> keywordMapping(boolean hasParent, DataSourceRequest.LeafMappingParametersGenerator request) {
         return () -> {
             var mapping = commonMappingParameters();
 
@@ -96,12 +98,15 @@ private Supplier<Map<String, Object>> keywordMapping(DataSourceRequest.LeafMappi
                 }
             }
 
-            if (ESTestCase.randomDouble() <= 0.2) {
-                mapping.put("ignore_above", ESTestCase.randomIntBetween(1, 100));
+            if (ESTestCase.randomDouble() <= 0.3) {
+                mapping.put("ignore_above", ESTestCase.randomIntBetween(1, 50));
             }
             if (ESTestCase.randomDouble() <= 0.2) {
                 mapping.put("null_value", ESTestCase.randomAlphaOfLengthBetween(0, 10));
             }
+            if (hasParent == false && ESTestCase.randomBoolean()) {
+                mapping.put("fields", stringSubField(request));
+            }
 
             return mapping;
         };
@@ -196,19 +201,15 @@ private Supplier<Map<String, Object>> geoPointMapping() {
         };
     }
 
-    private Supplier<Map<String, Object>> textMapping(DataSourceRequest.LeafMappingParametersGenerator request) {
+    private Supplier<Map<String, Object>> textMapping(boolean hasParent, DataSourceRequest.LeafMappingParametersGenerator request) {
         return () -> {
             var mapping = new HashMap<String, Object>();
 
             mapping.put("store", ESTestCase.randomBoolean());
             mapping.put("index", ESTestCase.randomBoolean());
 
-            if (ESTestCase.randomDouble() <= 0.1) {
-                var keywordMultiFieldMapping = keywordMapping(request).get();
-                keywordMultiFieldMapping.put("type", "keyword");
-                keywordMultiFieldMapping.remove("copy_to");
-
-                mapping.put("fields", Map.of("kwd", keywordMultiFieldMapping));
+            if (hasParent == false && ESTestCase.randomBoolean()) {
+                mapping.put("fields", stringSubField(request));
             }
 
             return mapping;
@@ -243,21 +244,57 @@ private Supplier<Map<String, Object>> constantKeywordMapping() {
         };
     }
 
-    private Supplier<Map<String, Object>> wildcardMapping() {
+    private Supplier<Map<String, Object>> wildcardMapping(boolean hasParent, DataSourceRequest.LeafMappingParametersGenerator request) {
         return () -> {
             var mapping = new HashMap<String, Object>();
 
-            if (ESTestCase.randomDouble() <= 0.2) {
-                mapping.put("ignore_above", ESTestCase.randomIntBetween(1, 100));
+            if (ESTestCase.randomDouble() <= 0.3) {
+                mapping.put("ignore_above", ESTestCase.randomIntBetween(1, 50));
             }
             if (ESTestCase.randomDouble() <= 0.2) {
                 mapping.put("null_value", ESTestCase.randomAlphaOfLengthBetween(0, 10));
             }
+            if (hasParent == false && ESTestCase.randomBoolean()) {
+                mapping.put("fields", stringSubField(request));
+            }
 
             return mapping;
         };
     }
 
+    private Supplier<Map<String, Object>> matchOnlyTextMapping(
+        boolean hasParent,
+        DataSourceRequest.LeafMappingParametersGenerator request
+    ) {
+        return () -> {
+            var mapping = new HashMap<String, Object>();
+            if (hasParent == false && ESTestCase.randomBoolean()) {
+                mapping.put("fields", stringSubField(request));
+            }
+            return mapping;
+        };
+    }
+
+    private Map<String, Object> stringSubField(DataSourceRequest.LeafMappingParametersGenerator request) {
+        FieldType parent = FieldType.tryParse(request.fieldType());
+        List<FieldType> stringTypes = List.of(FieldType.TEXT, FieldType.MATCH_ONLY_TEXT, FieldType.KEYWORD, FieldType.WILDCARD);
+        var childType = ESTestCase.randomValueOtherThan(parent, () -> ESTestCase.randomFrom(stringTypes));
+        var child = switch (childType) {
+            case TEXT -> textMapping(true, request).get();
+            case MATCH_ONLY_TEXT -> matchOnlyTextMapping(true, request).get();
+            case WILDCARD -> wildcardMapping(true, request).get();
+            case KEYWORD -> {
+                var mapping = keywordMapping(true, request).get();
+                mapping.remove("copy_to");
+                yield mapping;
+            }
+            default -> throw new AssertionError("unreachable");
+        };
+
+        child.put("type", childType.toString());
+        return Map.of("subfield_" + childType, child);
+    }
+
     public static HashMap<String, Object> commonMappingParameters() {
         var map = new HashMap<String, Object>();
         map.put("store", ESTestCase.randomBoolean());

test/framework/src/main/java/org/elasticsearch/datageneration/fields/leaf/MatchOnlyTextFieldDataGenerator.java

@@ -0,0 +1,28 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the "Elastic License
+ * 2.0", the "GNU Affero General Public License v3.0 only", and the "Server Side
+ * Public License v 1"; you may not use this file except in compliance with, at
+ * your election, the "Elastic License 2.0", the "GNU Affero General Public
+ * License v3.0 only", or the "Server Side Public License, v 1".
+ */
+
+package org.elasticsearch.datageneration.fields.leaf;
+
+import org.elasticsearch.datageneration.FieldDataGenerator;
+import org.elasticsearch.datageneration.datasource.DataSource;
+
+import java.util.Map;
+
+public class MatchOnlyTextFieldDataGenerator implements FieldDataGenerator {
+    private final FieldDataGenerator textGenerator;
+
+    public MatchOnlyTextFieldDataGenerator(DataSource dataSource) {
+        this.textGenerator = new TextFieldDataGenerator(dataSource);
+    }
+
+    @Override
+    public Object generateValue(Map<String, Object> fieldMapping) {
+        return textGenerator.generateValue(fieldMapping);
+    }
+}

test/framework/src/main/java/org/elasticsearch/datageneration/matchers/source/FieldSpecificMatcher.java

@@ -63,6 +63,7 @@ static Map<String, FieldSpecificMatcher> matchers(
                 put("shape", new ExactMatcher("shape", actualMappings, actualSettings, expectedMappings, expectedSettings));
                 put("geo_point", new GeoPointMatcher(actualMappings, actualSettings, expectedMappings, expectedSettings));
                 put("text", new TextMatcher(actualMappings, actualSettings, expectedMappings, expectedSettings));
+                put("match_only_text", new MatchOnlyTextMatcher(actualMappings, actualSettings, expectedMappings, expectedSettings));
                 put("ip", new IpMatcher(actualMappings, actualSettings, expectedMappings, expectedSettings));
                 put("constant_keyword", new ConstantKeywordMatcher(actualMappings, actualSettings, expectedMappings, expectedSettings));
                 put("wildcard", new WildcardMatcher(actualMappings, actualSettings, expectedMappings, expectedSettings));
@@ -621,6 +622,10 @@ class TextMatcher implements FieldSpecificMatcher {
             this.expectedSettings = expectedSettings;
         }
 
+        public String type() {
+            return "text";
+        }
+
         @Override
         @SuppressWarnings("unchecked")
         public MatchResult match(
@@ -643,7 +648,7 @@ public MatchResult match(
             if (multiFields != null) {
                 var keywordMatcher = new KeywordMatcher(actualMappings, actualSettings, expectedMappings, expectedSettings);
 
-                var keywordFieldMapping = (Map<String, Object>) multiFields.get("kwd");
+                var keywordFieldMapping = (Map<String, Object>) multiFields.get("subfield_keyword");
                 var keywordMatchResult = keywordMatcher.match(actual, expected, keywordFieldMapping, keywordFieldMapping);
                 if (keywordMatchResult.isMatch()) {
                     return MatchResult.match();
@@ -656,7 +661,7 @@ public MatchResult match(
                     actualSettings,
                     expectedMappings,
                     expectedSettings,
-                    "Values of type [text] don't match, " + prettyPrintCollections(actual, expected)
+                    "Values of type [" + type() + "] don't match, " + prettyPrintCollections(actual, expected)
                 )
             );
         }
@@ -670,6 +675,22 @@ private Set<Object> normalize(List<Object> values) {
         }
     }
 
+    class MatchOnlyTextMatcher extends TextMatcher {
+        MatchOnlyTextMatcher(
+            XContentBuilder actualMappings,
+            Settings.Builder actualSettings,
+            XContentBuilder expectedMappings,
+            Settings.Builder expectedSettings
+        ) {
+            super(actualMappings, actualSettings, expectedMappings, expectedSettings);
+        }
+
+        @Override
+        public String type() {
+            return "match_only_text";
+        }
+    }
+
     class IpMatcher extends GenericMappingAwareMatcher {
         IpMatcher(
             XContentBuilder actualMappings,

test/framework/src/main/java/org/elasticsearch/datageneration/queries/LeafQueryGenerator.java

@@ -12,10 +12,7 @@
 import org.elasticsearch.datageneration.FieldType;
 import org.elasticsearch.index.query.QueryBuilder;
 import org.elasticsearch.index.query.QueryBuilders;
-import org.elasticsearch.test.ESTestCase;
 
-import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 
@@ -28,7 +25,7 @@ public interface LeafQueryGenerator {
      * @param type the type to build a query for
      * @return a generator that can build queries for this type
      */
-    static LeafQueryGenerator buildForType(String type) {
+    static LeafQueryGenerator buildForType(String type, MappingPredicates mappingPredicates) {
         LeafQueryGenerator noQueries = (Map<String, Object> fieldMapping, String path, Object value) -> List.of();
 
         FieldType fieldType = FieldType.tryParse(type);
@@ -38,8 +35,9 @@ static LeafQueryGenerator buildForType(String type) {
 
         return switch (fieldType) {
             case KEYWORD -> new KeywordQueryGenerator();
-            case TEXT -> new TextQueryGenerator();
             case WILDCARD -> new WildcardQueryGenerator();
+            case TEXT -> new TextQueryGenerator();
+            case MATCH_ONLY_TEXT -> new MatchOnlyTextQueryGenerator(mappingPredicates);
             default -> noQueries;
         };
     }
@@ -53,13 +51,14 @@ public List<QueryBuilder> generate(Map<String, Object> fieldMapping, String path
                     return List.of();
                 }
             }
-            return List.of(QueryBuilders.termQuery(path, value));
+            return List.of(QueryBuilders.termQuery(path, value), QueryBuilders.matchQuery(path, value));
         }
     }
 
     class WildcardQueryGenerator implements LeafQueryGenerator {
         public List<QueryBuilder> generate(Map<String, Object> fieldMapping, String path, Object value) {
-            // Queries with emojis can currently fail due to https://github.com/elastic/elasticsearch/issues/132144
+            // TODO remove when fixed
+            // queries with emojis can currently fail due to https://github.com/elastic/elasticsearch/issues/132144
             if (containsHighSurrogates((String) value)) {
                 return List.of();
             }
@@ -76,25 +75,20 @@ public List<QueryBuilder> generate(Map<String, Object> fieldMapping, String path
                 }
             }
 
-            var results = new ArrayList<QueryBuilder>();
-            results.add(QueryBuilders.matchQuery(path, value));
-            var phraseQuery = buildPhraseQuery(path, (String) value);
-            if (phraseQuery != null) {
-                results.add(phraseQuery);
-            }
-            return results;
+            return List.of(QueryBuilders.matchQuery(path, value), QueryBuilders.matchPhraseQuery(path, value));
         }
+    }
+
+    record MatchOnlyTextQueryGenerator(MappingPredicates mappingPredicates) implements LeafQueryGenerator {
 
-        private static QueryBuilder buildPhraseQuery(String path, String value) {
-            var tokens = Arrays.asList(value.split("[^a-zA-Z0-9]"));
-            if (tokens.isEmpty()) {
-                return null;
+        public List<QueryBuilder> generate(Map<String, Object> fieldMapping, String path, Object value) {
+            // TODO remove when fixed
+            // match_only_text in nested context fails for synthetic source https://github.com/elastic/elasticsearch/issues/132352
+            if (mappingPredicates.inNestedContext(path)) {
+                return List.of(QueryBuilders.matchQuery(path, value));
             }
 
-            int low = ESTestCase.randomIntBetween(0, tokens.size() - 1);
-            int hi = ESTestCase.randomIntBetween(low + 1, tokens.size());
-            var phrase = String.join(" ", tokens.subList(low, hi));
-            return QueryBuilders.matchPhraseQuery(path, phrase);
+            return List.of(QueryBuilders.matchQuery(path, value), QueryBuilders.matchPhraseQuery(path, value));
         }
     }