Convert test field mappers to parametrized forms (#63018)

Relates to #62988

server/src/internalClusterTest/java/org/elasticsearch/index/mapper/ExternalValuesMapperIntegrationIT.java

@@ -29,8 +29,8 @@ import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
 import org.elasticsearch.test.ESIntegTestCase;
 import org.locationtech.jts.geom.Coordinate;
 
-import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 
 import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertSearchResponse;
 import static org.hamcrest.Matchers.equalTo;
@@ -38,7 +38,7 @@ import static org.hamcrest.Matchers.equalTo;
 public class ExternalValuesMapperIntegrationIT extends ESIntegTestCase {
     @Override
     protected Collection<Class<? extends Plugin>> nodePlugins() {
-        return Arrays.asList(ExternalMapperPlugin.class);
+        return Collections.singletonList(ExternalMapperPlugin.class);
     }
 
     public void testHighlightingOnCustomString() throws Exception {

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

@@ -23,7 +23,6 @@ import org.apache.lucene.analysis.Analyzer;
 import org.apache.lucene.analysis.TokenStream;
 import org.apache.lucene.analysis.Tokenizer;
 import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
-import org.apache.lucene.document.FieldType;
 import org.apache.lucene.util.LuceneTestCase;
 import org.elasticsearch.index.analysis.AnalyzerScope;
 import org.elasticsearch.index.analysis.NamedAnalyzer;
@@ -33,7 +32,6 @@ import java.io.IOException;
 import java.io.StringReader;
 import java.util.Arrays;
 import java.util.Collections;
-import java.util.List;
 
 public class DocumentFieldMapperTests extends LuceneTestCase {
 
@@ -78,14 +76,14 @@ public class DocumentFieldMapperTests extends LuceneTestCase {
         }
     }
 
-    static class FakeFieldMapper extends FieldMapper {
+    static class FakeFieldMapper extends ParametrizedFieldMapper {
 
         FakeFieldMapper(FakeFieldType fieldType) {
-            super(fieldType.name(), new FieldType(), fieldType, MultiFields.empty(), CopyTo.empty());
+            super(fieldType.name(), fieldType, MultiFields.empty(), CopyTo.empty());
         }
 
         @Override
-        protected void parseCreateField(ParseContext context) throws IOException {
+        protected void parseCreateField(ParseContext context) {
         }
 
         @Override
@@ -94,15 +92,14 @@ public class DocumentFieldMapperTests extends LuceneTestCase {
         }
 
         @Override
-        protected void mergeOptions(FieldMapper other, List<String> conflicts) {
-
+        protected String contentType() {
+            return null;
         }
 
         @Override
-        protected String contentType() {
+        public Builder getMergeBuilder() {
             return null;
         }
-
     }
 
     public void testAnalyzers() throws IOException {

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

@@ -19,11 +19,9 @@
 
 package org.elasticsearch.index.mapper;
 
-import org.apache.lucene.document.FieldType;
 import org.elasticsearch.common.collect.Iterators;
 import org.elasticsearch.common.geo.GeoPoint;
 import org.elasticsearch.common.geo.builders.PointBuilder;
-import org.elasticsearch.common.xcontent.XContentBuilder;
 import org.elasticsearch.geometry.Point;
 import org.elasticsearch.search.lookup.SearchLookup;
 
@@ -34,9 +32,6 @@ import java.util.Arrays;
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
-import java.util.Map;
-
-import static org.elasticsearch.index.mapper.TypeParsers.parseField;
 
 /**
  * This mapper add a new sub fields
@@ -45,7 +40,7 @@ import static org.elasticsearch.index.mapper.TypeParsers.parseField;
  * .point GeoPoint type
  * .shape GeoShape type
  */
-public class ExternalMapper extends FieldMapper {
+public class ExternalMapper extends ParametrizedFieldMapper {
 
     public static class Names {
         public static final String FIELD_BIN = "bin";
@@ -54,27 +49,26 @@ public class ExternalMapper extends FieldMapper {
         public static final String FIELD_SHAPE = "shape";
     }
 
-    public static class Builder extends FieldMapper.Builder<Builder> {
+    public static class Builder extends ParametrizedFieldMapper.Builder {
 
-        private BinaryFieldMapper.Builder binBuilder = new BinaryFieldMapper.Builder(Names.FIELD_BIN);
-        private BooleanFieldMapper.Builder boolBuilder = new BooleanFieldMapper.Builder(Names.FIELD_BOOL);
-        private GeoPointFieldMapper.Builder latLonPointBuilder = new GeoPointFieldMapper.Builder(Names.FIELD_POINT);
-        private GeoShapeFieldMapper.Builder shapeBuilder = new GeoShapeFieldMapper.Builder(Names.FIELD_SHAPE);
-        private Mapper.Builder stringBuilder;
-        private String generatedValue;
-        private String mapperName;
+        private final BinaryFieldMapper.Builder binBuilder = new BinaryFieldMapper.Builder(Names.FIELD_BIN);
+        private final BooleanFieldMapper.Builder boolBuilder = new BooleanFieldMapper.Builder(Names.FIELD_BOOL);
+        private final GeoPointFieldMapper.Builder latLonPointBuilder = new GeoPointFieldMapper.Builder(Names.FIELD_POINT);
+        private final GeoShapeFieldMapper.Builder shapeBuilder = new GeoShapeFieldMapper.Builder(Names.FIELD_SHAPE);
+        private final Mapper.Builder<?> stringBuilder;
+        private final String generatedValue;
+        private final String mapperName;
 
         public Builder(String name, String generatedValue, String mapperName) {
-            super(name, new FieldType());
-            this.builder = this;
+            super(name);
             this.stringBuilder = new TextFieldMapper.Builder(name).store(false);
             this.generatedValue = generatedValue;
             this.mapperName = mapperName;
         }
 
-        public Builder string(Mapper.Builder content) {
-            this.stringBuilder = content;
-            return this;
+        @Override
+        protected List<Parameter<?>> getParameters() {
+            return Collections.emptyList();
         }
 
         @Override
@@ -83,36 +77,17 @@ public class ExternalMapper extends FieldMapper {
             BinaryFieldMapper binMapper = binBuilder.build(context);
             BooleanFieldMapper boolMapper = boolBuilder.build(context);
             GeoPointFieldMapper pointMapper = (GeoPointFieldMapper) latLonPointBuilder.build(context);
-            AbstractShapeGeometryFieldMapper shapeMapper = shapeBuilder.build(context);
+            AbstractShapeGeometryFieldMapper<?, ?> shapeMapper = shapeBuilder.build(context);
             FieldMapper stringMapper = (FieldMapper)stringBuilder.build(context);
             context.path().remove();
 
-            return new ExternalMapper(name, buildFullName(context), fieldType, generatedValue, mapperName, binMapper, boolMapper,
-                pointMapper, shapeMapper, stringMapper, multiFieldsBuilder.build(this, context), copyTo, true);
-        }
-
-        @Override
-        public Builder index(boolean index) {
-            throw new UnsupportedOperationException();
+            return new ExternalMapper(name, buildFullName(context), generatedValue, mapperName, binMapper, boolMapper,
+                pointMapper, shapeMapper, stringMapper, multiFieldsBuilder.build(this, context), copyTo.build());
         }
     }
 
-    public static class TypeParser implements Mapper.TypeParser {
-
-        private String generatedValue;
-        private String mapperName;
-
-        TypeParser(String mapperName, String generatedValue) {
-            this.mapperName = mapperName;
-            this.generatedValue = generatedValue;
-        }
-
-        @Override
-        public Mapper.Builder<?> parse(String name, Map<String, Object> node, ParserContext parserContext) throws MapperParsingException {
-            ExternalMapper.Builder builder = new ExternalMapper.Builder(name, generatedValue, mapperName);
-            parseField(builder, name, node, parserContext);
-            return builder;
-        }
+    public static TypeParser parser(String mapperName, String generatedValue) {
+        return new TypeParser((n, c) -> new Builder(n, generatedValue, mapperName));
     }
 
     static class ExternalFieldType extends TermBasedFieldType {
@@ -130,18 +105,18 @@ public class ExternalMapper extends FieldMapper {
     private final String generatedValue;
     private final String mapperName;
 
-    private BinaryFieldMapper binMapper;
-    private BooleanFieldMapper boolMapper;
-    private GeoPointFieldMapper pointMapper;
-    private AbstractShapeGeometryFieldMapper shapeMapper;
-    private FieldMapper stringMapper;
+    private final BinaryFieldMapper binMapper;
+    private final BooleanFieldMapper boolMapper;
+    private final GeoPointFieldMapper pointMapper;
+    private final AbstractShapeGeometryFieldMapper<?, ?> shapeMapper;
+    private final FieldMapper stringMapper;
 
-    public ExternalMapper(String simpleName, String contextName, FieldType fieldType,
+    public ExternalMapper(String simpleName, String contextName,
                           String generatedValue, String mapperName,
                           BinaryFieldMapper binMapper, BooleanFieldMapper boolMapper, GeoPointFieldMapper pointMapper,
-                          AbstractShapeGeometryFieldMapper shapeMapper, FieldMapper stringMapper,
-                          MultiFields multiFields, CopyTo copyTo, boolean indexed) {
-        super(simpleName, fieldType, new ExternalFieldType(contextName, indexed, fieldType.stored(), false), multiFields, copyTo);
+                          AbstractShapeGeometryFieldMapper<?, ?> shapeMapper, FieldMapper stringMapper,
+                          MultiFields multiFields, CopyTo copyTo) {
+        super(simpleName, new ExternalFieldType(contextName, true, true, false), multiFields, copyTo);
         this.generatedValue = generatedValue;
         this.mapperName = mapperName;
         this.binMapper = binMapper;
@@ -159,8 +134,8 @@ public class ExternalMapper extends FieldMapper {
         boolMapper.parse(context.createExternalValueContext(true));
 
         // Let's add a Dummy Point
-        Double lat = 42.0;
-        Double lng = 51.0;
+        double lat = 42.0;
+        double lng = 51.0;
         ArrayList<GeoPoint> points = new ArrayList<>();
         points.add(new GeoPoint(lat, lng));
         pointMapper.parse(context.createExternalValueContext(points));
@@ -182,7 +157,7 @@ public class ExternalMapper extends FieldMapper {
     }
 
     @Override
-    protected void parseCreateField(ParseContext context) throws IOException {
+    protected void parseCreateField(ParseContext context) {
         throw new UnsupportedOperationException();
     }
 
@@ -202,17 +177,8 @@ public class ExternalMapper extends FieldMapper {
     }
 
     @Override
-    protected void mergeOptions(FieldMapper other, List<String> conflicts) {
-
-    }
-
-    @Override
-    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject(simpleName());
-        builder.field("type", mapperName);
-        multiFields.toXContent(builder, params);
-        builder.endObject();
-        return builder;
+    public ParametrizedFieldMapper.Builder getMergeBuilder() {
+        return new Builder(simpleName(), generatedValue, mapperName);
     }
 
     @Override

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

@@ -34,9 +34,9 @@ public class ExternalMapperPlugin extends Plugin implements MapperPlugin {
     @Override
     public Map<String, Mapper.TypeParser> getMappers() {
         return Map.of(
-                EXTERNAL, new ExternalMapper.TypeParser(EXTERNAL, "foo"),
-                EXTERNAL_BIS, new ExternalMapper.TypeParser(EXTERNAL_BIS, "bar"),
-                EXTERNAL_UPPER, new ExternalMapper.TypeParser(EXTERNAL_UPPER, "FOO BAR"),
+                EXTERNAL, ExternalMapper.parser(EXTERNAL, "foo"),
+                EXTERNAL_BIS, ExternalMapper.parser(EXTERNAL_BIS, "bar"),
+                EXTERNAL_UPPER, ExternalMapper.parser(EXTERNAL_UPPER, "FOO BAR"),
                 FakeStringFieldMapper.CONTENT_TYPE, new FakeStringFieldMapper.TypeParser());
     }
 

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

@@ -104,9 +104,7 @@ public class FieldTypeLookupTests extends ESTestCase {
             .build(context);
 
         MockFieldMapper otherField = new MockFieldMapper.Builder("other_field")
-            .copyTo(new FieldMapper.CopyTo.Builder()
-                .add("field")
-                .build())
+            .copyTo("field")
             .build(context);
 
         FieldTypeLookup lookup = new FieldTypeLookup(Arrays.asList(field, otherField), emptyList());

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

@@ -19,18 +19,16 @@
 
 package org.elasticsearch.index.mapper;
 
-import org.apache.lucene.document.FieldType;
 import org.elasticsearch.Version;
 import org.elasticsearch.cluster.metadata.IndexMetadata;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.search.lookup.SearchLookup;
 
-import java.io.IOException;
 import java.util.Collections;
 import java.util.List;
 
 // this sucks how much must be overridden just do get a dummy field mapper...
-public class MockFieldMapper extends FieldMapper {
+public class MockFieldMapper extends ParametrizedFieldMapper {
     static Settings DEFAULT_SETTINGS = Settings.builder()
         .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT.id)
         .build();
@@ -40,7 +38,7 @@ public class MockFieldMapper extends FieldMapper {
     }
 
     public MockFieldMapper(MappedFieldType fieldType) {
-        super(findSimpleName(fieldType.name()), new FieldType(), fieldType,
+        super(findSimpleName(fieldType.name()), fieldType,
             MultiFields.empty(), new CopyTo.Builder().build());
     }
 
@@ -48,7 +46,12 @@ public class MockFieldMapper extends FieldMapper {
                            MappedFieldType fieldType,
                            MultiFields multifields,
                            CopyTo copyTo) {
-        super(findSimpleName(fullName), new FieldType(), fieldType, multifields, copyTo);
+        super(findSimpleName(fullName), fieldType, multifields, copyTo);
+    }
+
+    @Override
+    public ParametrizedFieldMapper.Builder getMergeBuilder() {
+        return new Builder(simpleName());
     }
 
     static String findSimpleName(String fullName) {
@@ -73,7 +76,7 @@ public class MockFieldMapper extends FieldMapper {
     }
 
     @Override
-    protected void parseCreateField(ParseContext context) throws IOException {
+    protected void parseCreateField(ParseContext context) {
     }
 
     @Override
@@ -81,24 +84,34 @@ public class MockFieldMapper extends FieldMapper {
         throw new UnsupportedOperationException();
     }
 
-    @Override
-    protected void mergeOptions(FieldMapper other, List<String> conflicts) {
-
-    }
-
-    public static class Builder extends FieldMapper.Builder<MockFieldMapper.Builder> {
-        private MappedFieldType fieldType;
+    public static class Builder extends ParametrizedFieldMapper.Builder {
+        private final MappedFieldType fieldType;
 
         protected Builder(String name) {
-            super(name, new FieldType());
+            super(name);
             this.fieldType = new FakeFieldType(name);
             this.builder = this;
         }
 
+        @Override
+        protected List<Parameter<?>> getParameters() {
+            return Collections.emptyList();
+        }
+
+        public Builder addMultiField(Builder builder) {
+            this.multiFieldsBuilder.add(builder);
+            return this;
+        }
+
+        public Builder copyTo(String field) {
+            this.copyTo.add(field);
+            return this;
+        }
+
         @Override
         public MockFieldMapper build(BuilderContext context) {
             MultiFields multiFields = multiFieldsBuilder.build(this, context);
-            return new MockFieldMapper(name(), fieldType, multiFields, copyTo);
+            return new MockFieldMapper(name(), fieldType, multiFields, copyTo.build());
         }
     }
 }