Add random tests with match_only_text multi-field

server/src/test/java/org/elasticsearch/index/mapper/blockloader/TextFieldBlockLoaderTests.java

@@ -41,7 +41,7 @@ public static Object expectedValue(Map<String, Object> fieldMapping, Object valu
 
         var fields = (Map<String, Object>) fieldMapping.get("fields");
         if (fields != null) {
-            var keywordMultiFieldMapping = (Map<String, Object>) fields.get("kwd");
+            var keywordMultiFieldMapping = (Map<String, Object>) fields.get("subfield_keyword");
             Object normalizer = fields.get("normalizer");
             boolean docValues = hasDocValues(keywordMultiFieldMapping, true);
             boolean store = keywordMultiFieldMapping.getOrDefault("store", false).equals(true);

server/src/test/java/org/elasticsearch/index/mapper/blockloader/TextFieldWithParentBlockLoaderTests.java

@@ -15,9 +15,7 @@
 import org.elasticsearch.datageneration.FieldType;
 import org.elasticsearch.datageneration.MappingGenerator;
 import org.elasticsearch.datageneration.Template;
-import org.elasticsearch.datageneration.datasource.DataSourceHandler;
-import org.elasticsearch.datageneration.datasource.DataSourceRequest;
-import org.elasticsearch.datageneration.datasource.DataSourceResponse;
+import org.elasticsearch.datageneration.datasource.MultifieldAddonHandler;
 import org.elasticsearch.index.mapper.BlockLoaderTestCase;
 import org.elasticsearch.index.mapper.BlockLoaderTestRunner;
 import org.elasticsearch.index.mapper.MapperServiceTestCase;
@@ -49,51 +47,8 @@ public TextFieldWithParentBlockLoaderTests(BlockLoaderTestCase.Params params) {
     // of text multi field in a keyword field.
     public void testBlockLoaderOfParentField() throws IOException {
         var template = new Template(Map.of("parent", new Template.Leaf("parent", FieldType.KEYWORD.toString())));
-        var specification = buildSpecification(List.of(new DataSourceHandler() {
-            @Override
-            public DataSourceResponse.LeafMappingParametersGenerator handle(DataSourceRequest.LeafMappingParametersGenerator request) {
-                // This is a bit tricky meta-logic.
-                // We want to customize mapping but to do this we need the mapping for the same field type
-                // so we use name to untangle this.
-                if (request.fieldName().equals("parent") == false) {
-                    return null;
-                }
-
-                return new DataSourceResponse.LeafMappingParametersGenerator(() -> {
-                    var dataSource = request.dataSource();
-
-                    var keywordParentMapping = dataSource.get(
-                        new DataSourceRequest.LeafMappingParametersGenerator(
-                            dataSource,
-                            "_field",
-                            FieldType.KEYWORD.toString(),
-                            request.eligibleCopyToFields(),
-                            request.dynamicMapping()
-                        )
-                    ).mappingGenerator().get();
-
-                    var textMultiFieldMapping = dataSource.get(
-                        new DataSourceRequest.LeafMappingParametersGenerator(
-                            dataSource,
-                            "_field",
-                            FieldType.TEXT.toString(),
-                            request.eligibleCopyToFields(),
-                            request.dynamicMapping()
-                        )
-                    ).mappingGenerator().get();
-
-                    // we don't need this here
-                    keywordParentMapping.remove("copy_to");
-
-                    textMultiFieldMapping.put("type", "text");
-                    textMultiFieldMapping.remove("fields");
-
-                    keywordParentMapping.put("fields", Map.of("mf", textMultiFieldMapping));
-
-                    return keywordParentMapping;
-                });
-            }
-        }));
+        var specification = buildSpecification(List.of(new MultifieldAddonHandler(Map.of(FieldType.KEYWORD, List.of(FieldType.TEXT)), 1f)));
+
         var mapping = new MappingGenerator(specification).generate(template);
         var fieldMapping = mapping.lookup().get("parent");
 
@@ -106,7 +61,7 @@ public DataSourceResponse.LeafMappingParametersGenerator handle(DataSourceReques
             ? createSytheticSourceMapperService(mappingXContent)
             : createMapperService(mappingXContent);
 
-        runner.runTest(mapperService, document, expected, "parent.mf");
+        runner.runTest(mapperService, document, expected, "parent.subfield_text");
     }
 
     @SuppressWarnings("unchecked")
@@ -123,7 +78,7 @@ private Object expected(Map<String, Object> fieldMapping, Object value, BlockLoa
         }
 
         // we are using block loader of the text field itself
-        var textFieldMapping = (Map<String, Object>) ((Map<String, Object>) fieldMapping.get("fields")).get("mf");
+        var textFieldMapping = (Map<String, Object>) ((Map<String, Object>) fieldMapping.get("fields")).get("subfield_text");
         return TextFieldBlockLoaderTests.expectedValue(textFieldMapping, value, params, testContext);
     }
 }

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

@@ -44,10 +44,11 @@ public DataSourceResponse.LeafMappingParametersGenerator handle(DataSourceReques
             case BOOLEAN -> booleanMapping();
             case DATE -> dateMapping();
             case GEO_POINT -> geoPointMapping();
-            case TEXT -> textMapping(request);
+            case TEXT -> textMapping();
             case IP -> ipMapping();
             case CONSTANT_KEYWORD -> constantKeywordMapping();
             case WILDCARD -> wildcardMapping();
+            case MATCH_ONLY_TEXT -> matchOnlyTextMapping();
         });
     }
 
@@ -96,8 +97,8 @@ 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));
@@ -196,21 +197,13 @@ private Supplier<Map<String, Object>> geoPointMapping() {
         };
     }
 
-    private Supplier<Map<String, Object>> textMapping(DataSourceRequest.LeafMappingParametersGenerator request) {
+    private Supplier<Map<String, Object>> textMapping() {
         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));
-            }
-
             return mapping;
         };
     }
@@ -247,8 +240,8 @@ private Supplier<Map<String, Object>> wildcardMapping() {
         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));
@@ -258,6 +251,10 @@ private Supplier<Map<String, Object>> wildcardMapping() {
         };
     }
 
+    private Supplier<Map<String, Object>> matchOnlyTextMapping() {
+        return HashMap::new;
+    }
+
     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/datasource/DefaultObjectGenerationHandler.java

@@ -20,6 +20,14 @@
 import static org.elasticsearch.test.ESTestCase.randomRealisticUnicodeOfCodepointLengthBetween;
 
 public class DefaultObjectGenerationHandler implements DataSourceHandler {
+
+    /**
+     * Field names will not be generated which start with `_reserved_`. Handlers can safely
+     * create field names starting with this prefix without the concern of randomly generated
+     * fields having the same name.
+     */
+    public static final String RESERVED_FIELD_NAME_PREFIX = "_reserved_";
+
     @Override
     public DataSourceResponse.ChildFieldGenerator handle(DataSourceRequest.ChildFieldGenerator request) {
         return new DataSourceResponse.ChildFieldGenerator() {
@@ -57,6 +65,9 @@ public String generateFieldName() {
                     if (fieldName.indexOf('.') != -1) {
                         continue;
                     }
+                    if (fieldName.startsWith(RESERVED_FIELD_NAME_PREFIX)) {
+                        continue;
+                    }
 
                     return fieldName;
                 }

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

@@ -0,0 +1,97 @@
+/*
+ * 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.datasource;
+
+import org.elasticsearch.datageneration.FieldType;
+import org.elasticsearch.test.ESTestCase;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class MultifieldAddonHandler implements DataSourceHandler {
+
+    private static final String PLACEHOLDER = DefaultObjectGenerationHandler.RESERVED_FIELD_NAME_PREFIX + "multifield";
+    private static final float DEFAULT_CHANCE_OF_CHILD_FIELD = 0.5f;
+    private final Map<FieldType, List<FieldType>> subfieldTypes;
+    private final float chanceOfChildField;
+
+    private static final List<FieldType> STRING_TYPES = List.of(
+        FieldType.TEXT,
+        FieldType.KEYWORD,
+        FieldType.MATCH_ONLY_TEXT,
+        FieldType.WILDCARD
+    );
+    public static MultifieldAddonHandler STRING_TYPE_HANDLER = new MultifieldAddonHandler(
+        STRING_TYPES.stream().collect(Collectors.toMap(t -> t, t -> STRING_TYPES.stream().filter(s -> s != t).toList()))
+    );
+
+    public MultifieldAddonHandler(Map<FieldType, List<FieldType>> subfieldTypes, float chanceOfChildField) {
+        this.subfieldTypes = subfieldTypes;
+        this.chanceOfChildField = chanceOfChildField;
+    }
+
+    public MultifieldAddonHandler(Map<FieldType, List<FieldType>> subfieldTypes) {
+        this(subfieldTypes, DEFAULT_CHANCE_OF_CHILD_FIELD);
+    }
+
+    @Override
+    public DataSourceResponse.LeafMappingParametersGenerator handle(DataSourceRequest.LeafMappingParametersGenerator request) {
+
+        // Need to delegate creation of the same type of field to other handlers. So skip request
+        // if it's for the placeholder name used when creating the child and parent fields.
+        if (request.fieldName().equals(PLACEHOLDER)) {
+            return null;
+        }
+
+        FieldType parentType = FieldType.tryParse(request.fieldType());
+        List<FieldType> childTypes = subfieldTypes.get(parentType);
+        if (childTypes == null) {
+            return null;
+        }
+
+        return new DataSourceResponse.LeafMappingParametersGenerator(() -> {
+            assert parentType != null;
+            var parent = getMappingForType(parentType, request);
+            if (ESTestCase.randomFloat() > chanceOfChildField) {
+                return parent;
+            }
+
+            var childType = ESTestCase.randomFrom(childTypes);
+            var child = getChildMappingForType(childType, request);
+
+            child.put("type", childType.toString());
+            String childName = "subfield_" + childType;
+            parent.put("fields", Map.of(childName, child));
+            return parent;
+        });
+    }
+
+    private static Map<String, Object> getChildMappingForType(FieldType type, DataSourceRequest.LeafMappingParametersGenerator request) {
+        Map<String, Object> mapping = getMappingForType(type, request);
+        mapping.remove("copy_to");
+        return mapping;
+    }
+
+    private static Map<String, Object> getMappingForType(FieldType type, DataSourceRequest.LeafMappingParametersGenerator request) {
+        return request.dataSource()
+            .get(
+                new DataSourceRequest.LeafMappingParametersGenerator(
+                    request.dataSource(),
+                    PLACEHOLDER,
+                    type.toString(),
+                    request.eligibleCopyToFields(),
+                    request.dynamicMapping()
+                )
+            )
+            .mappingGenerator()
+            .get();
+    }
+}

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);
+    }
+}