Dont test runtime fields

Author: parkertimmins

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

@@ -10,6 +10,7 @@
 package org.elasticsearch.datageneration.queries;
 
 import org.apache.lucene.search.join.ScoreMode;
+import org.elasticsearch.datageneration.Mapping;
 import org.elasticsearch.index.query.QueryBuilder;
 import org.elasticsearch.index.query.QueryBuilders;
 
@@ -20,19 +21,24 @@
 
 public class QueryGenerator {
 
-    private final Map<String, Object> mappingRaw;
+    private final Mapping mapping;
 
-    public QueryGenerator(Map<String, Object> mappingRaw) {
-        this.mappingRaw = mappingRaw;
+    public QueryGenerator(Mapping mapping) {
+        this.mapping = mapping;
     }
 
-    public List<QueryBuilder> generateQueries(String type, String path, Map<String, Object> mapping, Object value) {
+    public List<QueryBuilder> generateQueries(String type, String path, Object value) {
         // This query generator cannot handle fields with periods in the name.
         if (path.equals("host.name")) {
             return List.of();
         }
+        // Can handle dynamically mapped fields, but not runtime fields
+        if (isRuntimeField(path)) {
+            return List.of();
+        }
         var leafQueryGenerator = LeafQueryGenerator.buildForType(type);
-        var leafQueries = leafQueryGenerator.generate(mapping, path, value);
+        var fieldMapping = mapping.lookup().get(path);
+        var leafQueries = leafQueryGenerator.generate(fieldMapping, path, value);
         return leafQueries.stream().map(q -> wrapInNestedQuery(path, q)).toList();
     }
 
@@ -48,7 +54,7 @@ private QueryBuilder wrapInNestedQuery(String path, QueryBuilder leafQuery) {
 
     @SuppressWarnings("unchecked")
     private List<String> getNestedPathPrefixes(String[] path) {
-        Map<String, Object> mapping = mappingRaw;
+        Map<String, Object> mapping = this.mapping.raw();
         mapping = (Map<String, Object>) mapping.get("_doc");
         mapping = (Map<String, Object>) mapping.get("properties");
 
@@ -70,4 +76,23 @@ private List<String> getNestedPathPrefixes(String[] path) {
         }
         return result;
     }
+
+    @SuppressWarnings("unchecked")
+    private boolean isRuntimeField(String path) {
+        String[] parts = path.split("\\.");
+        var topLevelMapping = (Map<String, Object>) mapping.raw().get("_doc");
+        boolean inRuntimeContext = "runtime".equals(topLevelMapping.get("dynamic"));
+        for (int i = 0; i < parts.length - 1; i++) {
+            var pathToHere = String.join(".", Arrays.copyOfRange(parts, 0, i + 1));
+            Map<String, Object> fieldMapping = mapping.lookup().get(pathToHere);
+            if (fieldMapping == null) {
+                break;
+            }
+            if (fieldMapping.containsKey("dynamic")) {
+                // lower down dynamic definitions override higher up behavior
+                inRuntimeContext = "runtime".equals(fieldMapping.get("dynamic"));
+            }
+        }
+        return inRuntimeContext;
+    }
 }

x-pack/plugin/logsdb/src/javaRestTest/java/org/elasticsearch/xpack/logsdb/qa/StandardVersusLogsIndexModeChallengeRestIT.java

@@ -144,7 +144,7 @@ public void testMatchAllQuery() throws IOException {
     }
 
     public void testRandomQueries() throws IOException {
-        int numberOfDocuments = ESTestCase.randomIntBetween(20, 80);
+        int numberOfDocuments = ESTestCase.randomIntBetween(10, 50);
         final List<XContentBuilder> documents = generateDocuments(numberOfDocuments);
         var mappingLookup = dataGenerationHelper.mapping().lookup();
         final List<Map<String, List<Object>>> docsNormalized = documents.stream().map(d -> {
@@ -154,19 +154,18 @@ public void testRandomQueries() throws IOException {
 
         indexDocuments(documents);
 
-        QueryGenerator queryGenerator = new QueryGenerator(dataGenerationHelper.mapping().raw());
+        QueryGenerator queryGenerator = new QueryGenerator(dataGenerationHelper.mapping());
         Map<String, String> fieldsTypes = dataGenerationHelper.getTemplateFieldTypes();
         for (var e : fieldsTypes.entrySet()) {
             var path = e.getKey();
             var type = e.getValue();
-            var mapping = mappingLookup.get(path);
             var docsWithFields = docsNormalized.stream().filter(d -> d.containsKey(path)).toList();
             if (docsWithFields.isEmpty() == false) {
                 var doc = randomFrom(docsWithFields);
                 List<Object> values = doc.get(path).stream().filter(Objects::nonNull).toList();
                 if (values.isEmpty() == false) {
                     Object value = randomFrom(values);
-                    List<QueryBuilder> queries = queryGenerator.generateQueries(type, path, mapping, value);
+                    List<QueryBuilder> queries = queryGenerator.generateQueries(type, path, value);
                     for (var query : queries) {
                         logger.info("Querying for field [{}] with value [{}]", path, value);