Explicitly say if stored fields aren't supported in MapperTestCase (#72474)

MapperTestCase has a check that if a field mapper supports stored fields,
those stored fields are available to index time scripts. Many of our mappers
do not support stored fields, and we try and catch this with an assumeFalse
so that those mappers do not run this test. However, this test is fragile - it
does not work for mappers created with an index version below 8.0, and it
misses mappers that always store their values, e.g. match_only_text.

This commit adds a new supportsStoredField method to MapperTestCase,
and overrides it for those mappers that do not support storing values. It
also adds a minimalStoredMapping method that defaults to the minimal
mapping plus a store parameter, which is overridden by match_only_text
because storing is not configurable and always available on this mapper.

modules/mapper-extras/src/internalClusterTest/java/org/elasticsearch/index/mapper/MatchOnlyTextFieldMapperTests.java

@@ -61,6 +61,12 @@ public class MatchOnlyTextFieldMapperTests extends MapperTestCase {
         b.field("type", "match_only_text");
     }
 
+    @Override
+    protected void minimalStoreMapping(XContentBuilder b) throws IOException {
+        // 'store' is always true
+        minimalMapping(b);
+    }
+
     public void testDefaults() throws IOException {
         DocumentMapper mapper = createDocumentMapper(fieldMapping(this::minimalMapping));
         assertEquals(Strings.toString(fieldMapping(this::minimalMapping)), mapper.mappingSource().toString());

modules/mapper-extras/src/test/java/org/elasticsearch/index/mapper/RankFeatureFieldMapperTests.java

@@ -52,6 +52,11 @@ public class RankFeatureFieldMapperTests extends MapperTestCase {
         assertTrue(fieldType.isSearchable());
     }
 
+    @Override
+    protected boolean supportsStoredFields() {
+        return false;
+    }
+
     @Override
     protected Collection<? extends Plugin> getPlugins() {
         return List.of(new MapperExtrasPlugin());

modules/mapper-extras/src/test/java/org/elasticsearch/index/mapper/RankFeaturesFieldMapperTests.java

@@ -46,6 +46,11 @@ public class RankFeaturesFieldMapperTests extends MapperTestCase {
         b.field("type", "rank_features");
     }
 
+    @Override
+    protected boolean supportsStoredFields() {
+        return false;
+    }
+
     @Override
     protected void registerParameters(ParameterChecker checker) throws IOException {
         checker.registerConflictCheck("positive_score_impact", b -> b.field("positive_score_impact", false));

server/src/test/java/org/elasticsearch/index/mapper/CompletionFieldMapperTests.java

@@ -73,6 +73,11 @@ public class CompletionFieldMapperTests extends MapperTestCase {
         b.field("max_input_length", 50);
     }
 
+    @Override
+    protected boolean supportsStoredFields() {
+        return false;
+    }
+
     @Override
     protected void registerParameters(ParameterChecker checker) throws IOException {
         checker.registerConflictCheck("analyzer", b -> b.field("analyzer", "standard"));

server/src/test/java/org/elasticsearch/index/mapper/GeoShapeFieldMapperTests.java

@@ -56,6 +56,11 @@ public class GeoShapeFieldMapperTests extends MapperTestCase {
         b.field("type", "geo_shape");
     }
 
+    @Override
+    protected boolean supportsStoredFields() {
+        return false;
+    }
+
     @Override
     protected Object getSampleValueForDocument() {
         return "POINT (14.0 15.0)";

server/src/test/java/org/elasticsearch/index/mapper/LegacyGeoShapeFieldMapperTests.java

@@ -54,6 +54,11 @@ public class LegacyGeoShapeFieldMapperTests extends MapperTestCase {
         b.field("type", "geo_shape").field("strategy", "recursive");
     }
 
+    @Override
+    protected boolean supportsStoredFields() {
+        return false;
+    }
+
     @Override
     protected void registerParameters(ParameterChecker checker) throws IOException {
 

server/src/test/java/org/elasticsearch/index/mapper/flattened/FlattenedFieldMapperTests.java

@@ -65,6 +65,11 @@ public class FlattenedFieldMapperTests extends MapperTestCase {
             m -> assertEquals(10, ((FlattenedFieldMapper)m).depthLimit()));
     }
 
+    @Override
+    protected boolean supportsStoredFields() {
+        return false;
+    }
+
     public void testDefaults() throws Exception {
         DocumentMapper mapper = createDocumentMapper(fieldMapping(this::minimalMapping));
         ParsedDocument parsedDoc = mapper.parse(source(b -> b.startObject("field").field("key", "value").endObject()));

test/framework/src/main/java/org/elasticsearch/index/mapper/MapperTestCase.java

@@ -643,24 +643,24 @@ public abstract class MapperTestCase extends MapperServiceTestCase {
         });
     }
 
+    protected boolean supportsStoredFields() {
+        return true;
+    }
+
+    protected void minimalStoreMapping(XContentBuilder b) throws IOException {
+        minimalMapping(b);
+        b.field("store", true);
+    }
+
     /**
      * Checks that loading stored fields for this field produces the same set of values
      * for query time scripts and index time scripts
      */
     public final void testIndexTimeStoredFieldsAccess() throws IOException {
 
-        MapperService mapperService;
-        try {
-            mapperService = createMapperService(fieldMapping(b -> {
-                minimalMapping(b);
-                b.field("store", true);
-            }));
-            assertParseMinimalWarnings();
-        } catch (MapperParsingException e) {
-            assertParseMinimalWarnings();
-            assumeFalse("Field type does not support stored fields", true);
-            return;
-        }
+        assumeTrue("Field type does not support stored fields", supportsStoredFields());
+        MapperService mapperService = createMapperService(fieldMapping(this::minimalStoreMapping));
+        assertParseMinimalWarnings();
 
         MappedFieldType fieldType = mapperService.fieldType("field");
         SourceToParse source = source(this::writeField);

x-pack/plugin/analytics/src/test/java/org/elasticsearch/xpack/analytics/mapper/HistogramFieldMapperTests.java

@@ -54,6 +54,11 @@ public class HistogramFieldMapperTests extends MapperTestCase {
         return false;
     }
 
+    @Override
+    protected boolean supportsStoredFields() {
+        return false;
+    }
+
     public void testParseValue() throws Exception {
         DocumentMapper mapper = createDocumentMapper(fieldMapping(this::minimalMapping));
         ParsedDocument doc = mapper.parse(

x-pack/plugin/mapper-aggregate-metric/src/test/java/org/elasticsearch/xpack/aggregatemetric/mapper/AggregateDoubleMetricFieldMapperTests.java

@@ -99,6 +99,11 @@ public class AggregateDoubleMetricFieldMapperTests extends MapperTestCase {
         return 50.0;
     }
 
+    @Override
+    protected boolean supportsStoredFields() {
+        return false;
+    }
+
     /**
      * Test parsing field mapping and adding simple field
      */

x-pack/plugin/mapper-constant-keyword/src/internalClusterTest/java/org/elasticsearch/xpack/constantkeyword/mapper/ConstantKeywordFieldMapperTests.java

@@ -58,6 +58,11 @@ public class ConstantKeywordFieldMapperTests extends MapperTestCase {
         return List.of(new ConstantKeywordMapperPlugin());
     }
 
+    @Override
+    protected boolean supportsStoredFields() {
+        return false;
+    }
+
     public void testDefaults() throws Exception {
         XContentBuilder mapping = fieldMapping(b -> b.field("type", "constant_keyword").field("value", "foo"));
         DocumentMapper mapper = createDocumentMapper(mapping);

x-pack/plugin/mapper-version/src/test/java/org/elasticsearch/xpack/versionfield/VersionStringFieldMapperTests.java

@@ -52,6 +52,11 @@ public class VersionStringFieldMapperTests extends MapperTestCase {
         // no configurable parameters
     }
 
+    @Override
+    protected boolean supportsStoredFields() {
+        return false;
+    }
+
     public void testDefaults() throws Exception {
         XContentBuilder mapping = fieldMapping(this::minimalMapping);
         DocumentMapper mapper = createDocumentMapper(mapping);

x-pack/plugin/spatial/src/test/java/org/elasticsearch/xpack/spatial/index/mapper/GeoShapeWithDocValuesFieldMapperTests.java

@@ -59,6 +59,11 @@ public class GeoShapeWithDocValuesFieldMapperTests extends MapperTestCase {
         return false;
     }
 
+    @Override
+    protected boolean supportsStoredFields() {
+        return false;
+    }
+
     @Override
     protected void registerParameters(ParameterChecker checker) throws IOException {
         checker.registerConflictCheck("doc_values", b -> b.field("doc_values", false));

x-pack/plugin/spatial/src/test/java/org/elasticsearch/xpack/spatial/index/mapper/ShapeFieldMapperTests.java

@@ -53,6 +53,11 @@ public class ShapeFieldMapperTests extends CartesianFieldMapperTests {
         });
     }
 
+    @Override
+    protected boolean supportsStoredFields() {
+        return false;
+    }
+
     public void testDefaultConfiguration() throws IOException {
         DocumentMapper mapper = createDocumentMapper(fieldMapping(this::minimalMapping));
         Mapper fieldMapper = mapper.mappers().getMapper(FIELD_NAME);

x-pack/plugin/vectors/src/test/java/org/elasticsearch/xpack/vectors/mapper/DenseVectorFieldMapperTests.java

@@ -53,6 +53,11 @@ public class DenseVectorFieldMapperTests extends MapperTestCase {
             fieldMapping(b -> b.field("type", "dense_vector").field("dims", 5)));
     }
 
+    @Override
+    protected boolean supportsStoredFields() {
+        return false;
+    }
+
     public void testDims() {
         {
             Exception e = expectThrows(MapperParsingException.class, () -> createMapperService(fieldMapping(b -> {

x-pack/plugin/wildcard/src/test/java/org/elasticsearch/xpack/wildcard/mapper/WildcardFieldMapperTests.java

@@ -102,6 +102,11 @@ public class WildcardFieldMapperTests extends MapperTestCase {
         return Collections.singleton(new Wildcard());
     }
 
+    @Override
+    protected boolean supportsStoredFields() {
+        return false;
+    }
+    
     @Override
     @Before
     public void setUp() throws Exception {