Remove type parameter from MapperService.documentMapper() (#48593)

We only have a single mapper per MapperService now anyway, so the extra
type parameter is surplus to requirements.

Relates to #41059

modules/percolator/src/main/java/org/elasticsearch/percolator/PercolateQueryBuilder.java

@@ -516,7 +516,7 @@ public class PercolateQueryBuilder extends AbstractQueryBuilder<PercolateQueryBu
         final DocumentMapper docMapper;
         final MapperService mapperService = context.getMapperService();
         String type = mapperService.documentMapper().type();
-        docMapper = mapperService.documentMapper(type);
+        docMapper = mapperService.documentMapper();
         for (BytesReference document : documents) {
             docs.add(docMapper.parse(new SourceToParse(context.index().getName(), "_temp_id", document, documentXContentType)));
         }

modules/percolator/src/test/java/org/elasticsearch/percolator/CandidateQueryTests.java

@@ -164,7 +164,7 @@ public class CandidateQueryTests extends ESSingleNodeTestCase {
                 .startObject("properties").startObject(queryField).field("type", "percolator").endObject().endObject()
                 .endObject().endObject());
         mapperService.merge("type", new CompressedXContent(percolatorMapper), MapperService.MergeReason.MAPPING_UPDATE);
-        fieldMapper = (PercolatorFieldMapper) mapperService.documentMapper("type").mappers().getMapper(queryField);
+        fieldMapper = (PercolatorFieldMapper) mapperService.documentMapper().mappers().getMapper(queryField);
         fieldType = (PercolatorFieldMapper.FieldType) fieldMapper.fieldType();
 
         queries = new ArrayList<>();

modules/percolator/src/test/java/org/elasticsearch/percolator/PercolatorFieldMapperTests.java

@@ -181,7 +181,7 @@ public class PercolatorFieldMapperTests extends ESSingleNodeTestCase {
         TermQuery termQuery2 = new TermQuery(new Term("field", "term2"));
         bq.add(termQuery2, Occur.SHOULD);
 
-        DocumentMapper documentMapper = mapperService.documentMapper("doc");
+        DocumentMapper documentMapper = mapperService.documentMapper();
         PercolatorFieldMapper fieldMapper = (PercolatorFieldMapper) documentMapper.mappers().getMapper(fieldName);
         IndexMetaData build = IndexMetaData.builder("")
             .settings(Settings.builder().put(IndexMetaData.SETTING_VERSION_CREATED, Version.CURRENT))
@@ -236,7 +236,7 @@ public class PercolatorFieldMapperTests extends ESSingleNodeTestCase {
             .rangeQuery(15, 20, true, true, null, null, null, null);
         bq.add(rangeQuery2, Occur.MUST);
 
-        DocumentMapper documentMapper = mapperService.documentMapper("doc");
+        DocumentMapper documentMapper = mapperService.documentMapper();
         IndexMetaData build = IndexMetaData.builder("")
             .settings(Settings.builder().put(IndexMetaData.SETTING_VERSION_CREATED, Version.CURRENT))
             .numberOfShards(1).numberOfReplicas(0).build();
@@ -290,7 +290,7 @@ public class PercolatorFieldMapperTests extends ESSingleNodeTestCase {
     public void testExtractTermsAndRanges_failed() throws Exception {
         addQueryFieldMappings();
         TermRangeQuery query = new TermRangeQuery("field1", new BytesRef("a"), new BytesRef("z"), true, true);
-        DocumentMapper documentMapper = mapperService.documentMapper("doc");
+        DocumentMapper documentMapper = mapperService.documentMapper();
         PercolatorFieldMapper fieldMapper = (PercolatorFieldMapper) documentMapper.mappers().getMapper(fieldName);
         IndexMetaData build = IndexMetaData.builder("")
             .settings(Settings.builder().put(IndexMetaData.SETTING_VERSION_CREATED, Version.CURRENT))
@@ -309,7 +309,7 @@ public class PercolatorFieldMapperTests extends ESSingleNodeTestCase {
     public void testExtractTermsAndRanges_partial() throws Exception {
         addQueryFieldMappings();
         PhraseQuery phraseQuery = new PhraseQuery("field", "term");
-        DocumentMapper documentMapper = mapperService.documentMapper("doc");
+        DocumentMapper documentMapper = mapperService.documentMapper();
         PercolatorFieldMapper fieldMapper = (PercolatorFieldMapper) documentMapper.mappers().getMapper(fieldName);
         IndexMetaData build = IndexMetaData.builder("")
             .settings(Settings.builder().put(IndexMetaData.SETTING_VERSION_CREATED, Version.CURRENT))
@@ -458,7 +458,7 @@ public class PercolatorFieldMapperTests extends ESSingleNodeTestCase {
     public void testPercolatorFieldMapper() throws Exception {
         addQueryFieldMappings();
         QueryBuilder queryBuilder = termQuery("field", "value");
-        ParsedDocument doc = mapperService.documentMapper("doc").parse(new SourceToParse("test", "1",
+        ParsedDocument doc = mapperService.documentMapper().parse(new SourceToParse("test", "1",
                         BytesReference.bytes(XContentFactory
                                 .jsonBuilder()
                                 .startObject()
@@ -477,7 +477,7 @@ public class PercolatorFieldMapperTests extends ESSingleNodeTestCase {
 
         // add an query for which we don't extract terms from
         queryBuilder = rangeQuery("field").from("a").to("z");
-        doc = mapperService.documentMapper("doc").parse(new SourceToParse("test", "1", BytesReference.bytes(XContentFactory
+        doc = mapperService.documentMapper().parse(new SourceToParse("test", "1", BytesReference.bytes(XContentFactory
                 .jsonBuilder()
                 .startObject()
                 .field(fieldName, queryBuilder)
@@ -503,7 +503,7 @@ public class PercolatorFieldMapperTests extends ESSingleNodeTestCase {
         // (it can't use shard data for rewriting purposes, because percolator queries run on MemoryIndex)
 
         for (QueryBuilder query : queries) {
-            ParsedDocument doc = mapperService.documentMapper("doc").parse(new SourceToParse("test", "1",
+            ParsedDocument doc = mapperService.documentMapper().parse(new SourceToParse("test", "1",
                     BytesReference.bytes(XContentFactory.jsonBuilder().startObject()
                     .field(fieldName, query)
                     .endObject()),
@@ -517,7 +517,7 @@ public class PercolatorFieldMapperTests extends ESSingleNodeTestCase {
         addQueryFieldMappings();
         client().prepareIndex("remote").setId("1").setSource("field", "value").get();
         QueryBuilder queryBuilder = termsLookupQuery("field", new TermsLookup("remote", "1", "field"));
-        ParsedDocument doc = mapperService.documentMapper("doc").parse(new SourceToParse("test", "1",
+        ParsedDocument doc = mapperService.documentMapper().parse(new SourceToParse("test", "1",
                         BytesReference.bytes(XContentFactory
                                 .jsonBuilder()
                                 .startObject()
@@ -538,7 +538,7 @@ public class PercolatorFieldMapperTests extends ESSingleNodeTestCase {
     public void testPercolatorFieldMapperUnMappedField() throws Exception {
         addQueryFieldMappings();
         MapperParsingException exception = expectThrows(MapperParsingException.class, () -> {
-            mapperService.documentMapper("doc").parse(new SourceToParse("test", "1", BytesReference.bytes(XContentFactory
+            mapperService.documentMapper().parse(new SourceToParse("test", "1", BytesReference.bytes(XContentFactory
                     .jsonBuilder()
                     .startObject()
                     .field(fieldName, termQuery("unmapped_field", "value"))
@@ -552,7 +552,7 @@ public class PercolatorFieldMapperTests extends ESSingleNodeTestCase {
 
     public void testPercolatorFieldMapper_noQuery() throws Exception {
         addQueryFieldMappings();
-        ParsedDocument doc = mapperService.documentMapper("doc").parse(new SourceToParse("test", "1", BytesReference
+        ParsedDocument doc = mapperService.documentMapper().parse(new SourceToParse("test", "1", BytesReference
                 .bytes(XContentFactory
                         .jsonBuilder()
                         .startObject()
@@ -561,7 +561,7 @@ public class PercolatorFieldMapperTests extends ESSingleNodeTestCase {
         assertThat(doc.rootDoc().getFields(fieldType.queryBuilderField.name()).length, equalTo(0));
 
         try {
-            mapperService.documentMapper("doc").parse(new SourceToParse("test", "1", BytesReference.bytes(XContentFactory
+            mapperService.documentMapper().parse(new SourceToParse("test", "1", BytesReference.bytes(XContentFactory
                     .jsonBuilder()
                     .startObject()
                     .nullField(fieldName)
@@ -597,7 +597,7 @@ public class PercolatorFieldMapperTests extends ESSingleNodeTestCase {
         mapperService.merge(typeName, new CompressedXContent(percolatorMapper), MapperService.MergeReason.MAPPING_UPDATE);
 
         QueryBuilder queryBuilder = matchQuery("field", "value");
-        ParsedDocument doc = mapperService.documentMapper(typeName).parse(new SourceToParse("test", "1",
+        ParsedDocument doc = mapperService.documentMapper().parse(new SourceToParse("test", "1",
                 BytesReference.bytes(jsonBuilder().startObject()
                         .field("query_field1", queryBuilder)
                         .field("query_field2", queryBuilder)
@@ -627,7 +627,7 @@ public class PercolatorFieldMapperTests extends ESSingleNodeTestCase {
         mapperService.merge(typeName, new CompressedXContent(percolatorMapper), MapperService.MergeReason.MAPPING_UPDATE);
 
         QueryBuilder queryBuilder = matchQuery("field", "value");
-        ParsedDocument doc = mapperService.documentMapper(typeName).parse(new SourceToParse("test", "1",
+        ParsedDocument doc = mapperService.documentMapper().parse(new SourceToParse("test", "1",
                 BytesReference.bytes(jsonBuilder().startObject().startObject("object_field")
                             .field("query_field", queryBuilder)
                         .endObject().endObject()),
@@ -636,7 +636,7 @@ public class PercolatorFieldMapperTests extends ESSingleNodeTestCase {
         BytesRef queryBuilderAsBytes = doc.rootDoc().getField("object_field.query_field.query_builder_field").binaryValue();
         assertQueryBuilder(queryBuilderAsBytes, queryBuilder);
 
-        doc = mapperService.documentMapper(typeName).parse(new SourceToParse("test", "1",
+        doc = mapperService.documentMapper().parse(new SourceToParse("test", "1",
                 BytesReference.bytes(jsonBuilder().startObject()
                             .startArray("object_field")
                                 .startObject().field("query_field", queryBuilder).endObject()
@@ -648,7 +648,7 @@ public class PercolatorFieldMapperTests extends ESSingleNodeTestCase {
         assertQueryBuilder(queryBuilderAsBytes, queryBuilder);
 
         MapperParsingException e = expectThrows(MapperParsingException.class, () -> {
-                    mapperService.documentMapper(typeName).parse(new SourceToParse("test", "1",
+                    mapperService.documentMapper().parse(new SourceToParse("test", "1",
                             BytesReference.bytes(jsonBuilder().startObject()
                                     .startArray("object_field")
                                         .startObject().field("query_field", queryBuilder).endObject()
@@ -733,7 +733,7 @@ public class PercolatorFieldMapperTests extends ESSingleNodeTestCase {
         query.endObject();
         query.endObject();
 
-        ParsedDocument doc = mapperService.documentMapper("doc").parse(new SourceToParse("test", "1",
+        ParsedDocument doc = mapperService.documentMapper().parse(new SourceToParse("test", "1",
                 BytesReference.bytes(XContentFactory.jsonBuilder().startObject()
                         .rawField(fieldName, new BytesArray(Strings.toString(query)).streamInput(), query.contentType())
                         .endObject()),
@@ -771,7 +771,7 @@ public class PercolatorFieldMapperTests extends ESSingleNodeTestCase {
         query.endObject();
         query.endObject();
 
-        doc = mapperService.documentMapper("doc").parse(new SourceToParse("test", "1",
+        doc = mapperService.documentMapper().parse(new SourceToParse("test", "1",
                 BytesReference.bytes(XContentFactory.jsonBuilder().startObject()
                         .rawField(fieldName, new BytesArray(Strings.toString(query)).streamInput(), query.contentType())
                         .endObject()),
@@ -857,7 +857,7 @@ public class PercolatorFieldMapperTests extends ESSingleNodeTestCase {
         QueryBuilder qb = boolQuery()
                 .must(boolQuery().must(termQuery("field", "value1")).must(termQuery("field", "value2")))
                 .must(boolQuery().must(termQuery("field", "value2")).must(termQuery("field", "value3")));
-        ParsedDocument doc = mapperService.documentMapper("doc").parse(new SourceToParse("test", "1",
+        ParsedDocument doc = mapperService.documentMapper().parse(new SourceToParse("test", "1",
                 BytesReference.bytes(XContentFactory.jsonBuilder().startObject()
                         .field(fieldName, qb)
                         .endObject()),
@@ -879,7 +879,7 @@ public class PercolatorFieldMapperTests extends ESSingleNodeTestCase {
                 .must(boolQuery().must(termQuery("field", "value2")).must(termQuery("field", "value3")))
                 .must(boolQuery().must(termQuery("field", "value3")).must(termQuery("field", "value4")))
                 .must(boolQuery().should(termQuery("field", "value4")).should(termQuery("field", "value5")));
-        doc = mapperService.documentMapper("doc").parse(new SourceToParse("test", "1",
+        doc = mapperService.documentMapper().parse(new SourceToParse("test", "1",
                 BytesReference.bytes(XContentFactory.jsonBuilder().startObject()
                         .field(fieldName, qb)
                         .endObject()),
@@ -904,7 +904,7 @@ public class PercolatorFieldMapperTests extends ESSingleNodeTestCase {
                 .should(boolQuery().should(termQuery("field", "value2")).should(termQuery("field", "value3")))
                 .should(boolQuery().should(termQuery("field", "value3")).should(termQuery("field", "value4")))
                 .should(boolQuery().should(termQuery("field", "value4")).should(termQuery("field", "value5")));
-        doc = mapperService.documentMapper("doc").parse(new SourceToParse("test", "1",
+        doc = mapperService.documentMapper().parse(new SourceToParse("test", "1",
                 BytesReference.bytes(XContentFactory.jsonBuilder().startObject()
                         .field(fieldName, qb)
                         .endObject()),

plugins/mapper-size/src/test/java/org/elasticsearch/index/mapper/size/SizeMappingTests.java

@@ -49,7 +49,7 @@ public class SizeMappingTests extends ESSingleNodeTestCase {
 
     public void testSizeEnabled() throws Exception {
         IndexService service = createIndex("test", Settings.EMPTY, "type", "_size", "enabled=true");
-        DocumentMapper docMapper = service.mapperService().documentMapper("type");
+        DocumentMapper docMapper = service.mapperService().documentMapper();
 
         BytesReference source = BytesReference
             .bytes(XContentFactory.jsonBuilder()
@@ -70,7 +70,7 @@ public class SizeMappingTests extends ESSingleNodeTestCase {
 
     public void testSizeDisabled() throws Exception {
         IndexService service = createIndex("test", Settings.EMPTY, "type", "_size", "enabled=false");
-        DocumentMapper docMapper = service.mapperService().documentMapper("type");
+        DocumentMapper docMapper = service.mapperService().documentMapper();
 
         BytesReference source = BytesReference
             .bytes(XContentFactory.jsonBuilder()
@@ -84,7 +84,7 @@ public class SizeMappingTests extends ESSingleNodeTestCase {
 
     public void testSizeNotSet() throws Exception {
         IndexService service = createIndex("test", Settings.EMPTY, "type");
-        DocumentMapper docMapper = service.mapperService().documentMapper("type");
+        DocumentMapper docMapper = service.mapperService().documentMapper();
 
         BytesReference source = BytesReference
             .bytes(XContentFactory.jsonBuilder()
@@ -98,7 +98,7 @@ public class SizeMappingTests extends ESSingleNodeTestCase {
 
     public void testThatDisablingWorksWhenMerging() throws Exception {
         IndexService service = createIndex("test", Settings.EMPTY, "type", "_size", "enabled=true");
-        DocumentMapper docMapper = service.mapperService().documentMapper("type");
+        DocumentMapper docMapper = service.mapperService().documentMapper();
         assertThat(docMapper.metadataMapper(SizeFieldMapper.class).enabled(), is(true));
 
         String disabledMapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")

server/src/main/java/org/elasticsearch/action/admin/indices/mapping/get/TransportGetFieldMappingsIndexAction.java

@@ -116,7 +116,7 @@ public class TransportGetFieldMappingsIndexAction
 
         Map<String, Map<String, FieldMappingMetaData>> typeMappings = new HashMap<>();
         for (String type : typeIntersection) {
-            DocumentMapper documentMapper = indexService.mapperService().documentMapper(type);
+            DocumentMapper documentMapper = indexService.mapperService().documentMapper();
             Map<String, FieldMappingMetaData> fieldMapping = findFieldMappingsByType(fieldPredicate, documentMapper, request);
             if (!fieldMapping.isEmpty()) {
                 typeMappings.put(type, fieldMapping);

server/src/main/java/org/elasticsearch/index/mapper/DocumentMapper.java

@@ -72,7 +72,7 @@ public class DocumentMapper implements ToXContentFragment {
             this.rootObjectMapper = builder.build(builderContext);
 
             final String type = rootObjectMapper.name();
-            final DocumentMapper existingMapper = mapperService.documentMapper(type);
+            final DocumentMapper existingMapper = mapperService.documentMapper();
             final Version indexCreatedVersion = mapperService.getIndexSettings().getIndexVersionCreated();
             final Map<String, TypeParser> metadataMapperParsers =
                 mapperService.mapperRegistry.getMetadataMapperParsers(indexCreatedVersion);

server/src/main/java/org/elasticsearch/index/mapper/MapperService.java

@@ -38,7 +38,6 @@ import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.xcontent.LoggingDeprecationHandler;
 import org.elasticsearch.common.xcontent.NamedXContentRegistry;
 import org.elasticsearch.common.xcontent.XContentFactory;
-import org.elasticsearch.common.xcontent.XContentHelper;
 import org.elasticsearch.common.xcontent.XContentParser;
 import org.elasticsearch.common.xcontent.XContentType;
 import org.elasticsearch.index.AbstractIndexComponent;
@@ -230,9 +229,9 @@ public class MapperService extends AbstractIndexComponent implements Closeable {
             // refresh mapping can happen when the parsing/merging of the mapping from the metadata doesn't result in the same
             // mapping, in this case, we send to the master to refresh its own version of the mappings (to conform with the
             // merge version of it, which it does when refreshing the mappings), and warn log it.
-            if (documentMapper(mappingType).mappingSource().equals(incomingMappingSource) == false) {
+            if (documentMapper().mappingSource().equals(incomingMappingSource) == false) {
                 logger.debug("[{}] parsed mapping [{}], and got different sources\noriginal:\n{}\nparsed:\n{}",
-                    index(), mappingType, incomingMappingSource, documentMapper(mappingType).mappingSource());
+                    index(), mappingType, incomingMappingSource, documentMapper().mappingSource());
 
                 requireRefresh = true;
             }
@@ -311,7 +310,7 @@ public class MapperService extends AbstractIndexComponent implements Closeable {
         MappingMetaData mappingMetaData = indexMetaData.mapping();
         if (mappingMetaData != null) {
             if (onlyUpdateIfNeeded) {
-                DocumentMapper existingMapper = documentMapper(mappingMetaData.type());
+                DocumentMapper existingMapper = documentMapper();
                 if (existingMapper == null || mappingMetaData.source().equals(existingMapper.mappingSource()) == false) {
                     map.put(mappingMetaData.type(), mappingMetaData.source());
                 }
@@ -586,16 +585,6 @@ public class MapperService extends AbstractIndexComponent implements Closeable {
         return mapper;
     }
 
-    /**
-     * Return the {@link DocumentMapper} for the given type.
-     */
-    public DocumentMapper documentMapper(String type) {
-        if (mapper != null && type.equals(mapper.type())) {
-            return mapper;
-        }
-        return null;
-    }
-
     /**
      * Returns {@code true} if the given {@code mappingSource} includes a type
      * as a top-level object.
@@ -604,12 +593,6 @@ public class MapperService extends AbstractIndexComponent implements Closeable {
         return mapping.size() == 1 && mapping.keySet().iterator().next().equals(type);
     }
 
-
-    public static boolean isMappingSourceTyped(String type, CompressedXContent mappingSource) {
-        Map<String, Object> root = XContentHelper.convertToMap(mappingSource.compressedReference(), true, XContentType.JSON).v2();
-        return isMappingSourceTyped(type, root);
-    }
-
     /**
      * Resolves a type from a mapping-related request into the type that should be used when
      * merging and updating mappings.
@@ -628,15 +611,15 @@ public class MapperService extends AbstractIndexComponent implements Closeable {
     }
 
     /**
-     * Returns the document mapper created, including a mapping update if the
-     * type has been dynamically created.
+     * Returns the document mapper for this MapperService.  If no mapper exists,
+     * creates one and returns that.
      */
-    public DocumentMapperForType documentMapperWithAutoCreate(String type) {
-        DocumentMapper mapper = documentMapper(type);
+    public DocumentMapperForType documentMapperWithAutoCreate() {
+        DocumentMapper mapper = documentMapper();
         if (mapper != null) {
             return new DocumentMapperForType(mapper, null);
         }
-        mapper = parse(type, null);
+        mapper = parse(SINGLE_MAPPING_NAME, null);
         return new DocumentMapperForType(mapper, mapper.mapping());
     }
 

server/src/main/java/org/elasticsearch/index/query/QueryShardContext.java

@@ -44,7 +44,6 @@ import org.elasticsearch.index.analysis.IndexAnalyzers;
 import org.elasticsearch.index.cache.bitset.BitsetFilterCache;
 import org.elasticsearch.index.fielddata.IndexFieldData;
 import org.elasticsearch.index.mapper.ContentPath;
-import org.elasticsearch.index.mapper.DocumentMapper;
 import org.elasticsearch.index.mapper.MappedFieldType;
 import org.elasticsearch.index.mapper.Mapper;
 import org.elasticsearch.index.mapper.MapperService;
@@ -224,14 +223,6 @@ public class QueryShardContext extends QueryRewriteContext {
         return mapperService.getObjectMapper(name);
     }
 
-    /**
-     * Returns s {@link DocumentMapper} instance for the given type.
-     * Delegates to {@link MapperService#documentMapper(String)}
-     */
-    public DocumentMapper documentMapper(String type) {
-        return mapperService.documentMapper(type);
-    }
-
     /**
      * Gets the search analyzer for the given field, or the default if there is none present for the field
      * TODO: remove this by moving defaults into mappers themselves

server/src/main/java/org/elasticsearch/index/shard/IndexShard.java

@@ -2655,8 +2655,7 @@ public class IndexShard extends AbstractIndexShardComponent implements IndicesCl
 
 
     private DocumentMapperForType docMapper() {
-        return mapperService.documentMapperWithAutoCreate(
-            mapperService.resolveDocumentType(MapperService.SINGLE_MAPPING_NAME));
+        return mapperService.documentMapperWithAutoCreate();
     }
 
     private EngineConfig newEngineConfig(LongSupplier globalCheckpointSupplier) {

server/src/main/java/org/elasticsearch/index/termvectors/TermVectorsService.java

@@ -324,7 +324,7 @@ public class TermVectorsService  {
     private static ParsedDocument parseDocument(IndexShard indexShard, String index, BytesReference doc,
                                                 XContentType xContentType, String routing) {
         MapperService mapperService = indexShard.mapperService();
-        DocumentMapperForType docMapper = mapperService.documentMapperWithAutoCreate(MapperService.SINGLE_MAPPING_NAME);
+        DocumentMapperForType docMapper = mapperService.documentMapperWithAutoCreate();
         ParsedDocument parsedDocument = docMapper.getDocumentMapper().parse(
                 new SourceToParse(index, "_id_for_tv_api", doc, xContentType, routing));
         if (docMapper.getMapping() != null) {

server/src/test/java/org/elasticsearch/cluster/coordination/RareClusterStateIT.java

@@ -331,7 +331,7 @@ public class RareClusterStateIT extends ESIntegTestCase {
             final IndexService indexService = indicesService.indexServiceSafe(index);
             assertNotNull(indexService);
             final MapperService mapperService = indexService.mapperService();
-            DocumentMapper mapper = mapperService.documentMapper("type");
+            DocumentMapper mapper = mapperService.documentMapper();
             assertNotNull(mapper);
             assertNotNull(mapper.mappers().getMapper("field"));
         });
@@ -354,7 +354,7 @@ public class RareClusterStateIT extends ESIntegTestCase {
             final IndexService indexService = indicesService.indexServiceSafe(index);
             assertNotNull(indexService);
             final MapperService mapperService = indexService.mapperService();
-            DocumentMapper mapper = mapperService.documentMapper("type");
+            DocumentMapper mapper = mapperService.documentMapper();
             assertNotNull(mapper);
             assertNotNull(mapper.mappers().getMapper("field2"));
         });

server/src/test/java/org/elasticsearch/cluster/metadata/MetaDataMappingServiceTests.java

@@ -46,7 +46,7 @@ public class MetaDataMappingServiceTests extends ESSingleNodeTestCase {
 
     public void testMappingClusterStateUpdateDoesntChangeExistingIndices() throws Exception {
         final IndexService indexService = createIndex("test", client().admin().indices().prepareCreate("test").addMapping("type"));
-        final CompressedXContent currentMapping = indexService.mapperService().documentMapper("type").mappingSource();
+        final CompressedXContent currentMapping = indexService.mapperService().documentMapper().mappingSource();
 
         final MetaDataMappingService mappingService = getInstanceFromNode(MetaDataMappingService.class);
         final ClusterService clusterService = getInstanceFromNode(ClusterService.class);
@@ -61,10 +61,10 @@ public class MetaDataMappingServiceTests extends ESSingleNodeTestCase {
         assertTrue(result.executionResults.values().iterator().next().isSuccess());
         // the task really was a mapping update
         assertThat(
-                indexService.mapperService().documentMapper("type").mappingSource(),
+                indexService.mapperService().documentMapper().mappingSource(),
                 not(equalTo(result.resultingState.metaData().index("test").mapping().source())));
         // since we never committed the cluster state update, the in-memory state is unchanged
-        assertThat(indexService.mapperService().documentMapper("type").mappingSource(), equalTo(currentMapping));
+        assertThat(indexService.mapperService().documentMapper().mappingSource(), equalTo(currentMapping));
     }
 
     public void testClusterStateIsNotChangedWithIdenticalMappings() throws Exception {

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

@@ -40,7 +40,7 @@ public class AllFieldMapperTests extends ESSingleNodeTestCase {
                 .put("index.analysis.analyzer.default_search.tokenizer", "standard").build());
         String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc").endObject().endObject());
         indexService.mapperService().merge("_doc", new CompressedXContent(mapping), MergeReason.MAPPING_UPDATE);
-        assertEquals(mapping, indexService.mapperService().documentMapper("_doc").mapping().toString());
+        assertEquals(mapping, indexService.mapperService().documentMapper().mapping().toString());
     }
 
 }

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

@@ -33,7 +33,7 @@ public class CamelCaseFieldNameTests extends ESSingleNodeTestCase {
 
         IndexService index = createIndex("test");
         client().admin().indices().preparePutMapping("test").setType("type").setSource(mapping, XContentType.JSON).get();
-        DocumentMapper documentMapper = index.mapperService().documentMapper("type");
+        DocumentMapper documentMapper = index.mapperService().documentMapper();
 
         ParsedDocument doc = documentMapper.parse(new SourceToParse("test", "1",
                         BytesReference.bytes(XContentFactory.jsonBuilder().startObject()
@@ -45,7 +45,7 @@ public class CamelCaseFieldNameTests extends ESSingleNodeTestCase {
         client().admin().indices().preparePutMapping("test").setType("type")
             .setSource(doc.dynamicMappingsUpdate().toString(), XContentType.JSON).get();
 
-        documentMapper = index.mapperService().documentMapper("type");
+        documentMapper = index.mapperService().documentMapper();
         assertNotNull(documentMapper.mappers().getMapper("thisIsCamelCase"));
         assertNull(documentMapper.mappers().getMapper("this_is_camel_case"));
 

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

@@ -71,7 +71,7 @@ public class CopyToMapperTests extends ESSingleNodeTestCase {
 
         IndexService index = createIndex("test");
         client().admin().indices().preparePutMapping("test").setType("type1").setSource(mapping, XContentType.JSON).get();
-        DocumentMapper docMapper = index.mapperService().documentMapper("type1");
+        DocumentMapper docMapper = index.mapperService().documentMapper();
         Mapper fieldMapper = docMapper.mappers().getMapper("copy_test");
 
         // Check json serialization
@@ -121,7 +121,7 @@ public class CopyToMapperTests extends ESSingleNodeTestCase {
         client().admin().indices().preparePutMapping("test").setType("type1")
             .setSource(parsedDoc.dynamicMappingsUpdate().toString(), XContentType.JSON).get();
 
-        docMapper = index.mapperService().documentMapper("type1");
+        docMapper = index.mapperService().documentMapper();
         fieldMapper = docMapper.mappers().getMapper("new_field");
         assertThat(fieldMapper.typeName(), equalTo("long"));
     }

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

@@ -156,7 +156,7 @@ public class DocumentMapperTests extends ESSingleNodeTestCase {
     public void testConcurrentMergeTest() throws Throwable {
         final MapperService mapperService = createIndex("test").mapperService();
         mapperService.merge("test", new CompressedXContent("{\"test\":{}}"), MapperService.MergeReason.MAPPING_UPDATE);
-        final DocumentMapper documentMapper = mapperService.documentMapper("test");
+        final DocumentMapper documentMapper = mapperService.documentMapper();
 
         DocumentFieldMappers dfm = documentMapper.mappers();
         try {

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

@@ -375,7 +375,7 @@ public class DocumentParserTests extends ESSingleNodeTestCase {
             .numberOfShards(1).numberOfReplicas(0).build();
         IndexSettings settings = new IndexSettings(build, Settings.EMPTY);
         ParseContext context = new ParseContext.InternalParseContext(settings,
-            mapperService.documentMapperParser(), mapperService.documentMapper("type"), null, null);
+            mapperService.documentMapperParser(), mapperService.documentMapper(), null, null);
         String[] nameParts = name.split("\\.");
         for (int i = 0; i < nameParts.length - 1; ++i) {
             context.path().add(nameParts[i]);

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

@@ -18,7 +18,6 @@
  */
 package org.elasticsearch.index.mapper;
 
-import org.apache.lucene.index.IndexOptions;
 import org.elasticsearch.Version;
 import org.elasticsearch.cluster.metadata.IndexMetaData;
 import org.elasticsearch.cluster.service.ClusterService;
@@ -34,9 +33,6 @@ import org.elasticsearch.common.xcontent.XContentType;
 import org.elasticsearch.common.xcontent.json.JsonXContent;
 import org.elasticsearch.index.IndexService;
 import org.elasticsearch.index.IndexSettings;
-import org.elasticsearch.index.mapper.BooleanFieldMapper.BooleanFieldType;
-import org.elasticsearch.index.mapper.DateFieldMapper.DateFieldType;
-import org.elasticsearch.index.mapper.NumberFieldMapper.NumberFieldType;
 import org.elasticsearch.plugins.Plugin;
 import org.elasticsearch.test.ESSingleNodeTestCase;
 import org.elasticsearch.test.InternalSettingsPlugin;
@@ -49,6 +45,7 @@ import java.util.Collections;
 import static java.util.Collections.emptyMap;
 import static org.elasticsearch.common.xcontent.XContentFactory.jsonBuilder;
 import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertAcked;
+import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.instanceOf;
 import static org.hamcrest.Matchers.nullValue;
@@ -436,104 +433,37 @@ public class DynamicMappingTests extends ESSingleNodeTestCase {
                 .endObject().endObject().endObject()), serialize(update));
     }
 
-    public void testReuseExistingMappings() throws IOException, Exception {
+    public void testReuseExistingMappings() throws Exception {
+
         IndexService indexService = createIndex("test", Settings.EMPTY, "type",
-                "my_field1", "type=text,store=true",
-                "my_field2", "type=integer,store=false",
-                "my_field3", "type=long,doc_values=false",
-                "my_field4", "type=float,index=false",
-                "my_field5", "type=double,store=true",
-                "my_field6", "type=date,doc_values=false",
-                "my_field7", "type=boolean,doc_values=false");
+            "my_field1", "type=text,store=true",
+            "my_field2", "type=integer,store=false",
+            "my_field3", "type=long,doc_values=false",
+            "my_field4", "type=float,index=false",
+            "my_field5", "type=double,store=true",
+            "my_field6", "type=date,doc_values=false",
+            "my_field7", "type=boolean,doc_values=false");
 
         // Even if the dynamic type of our new field is long, we already have a mapping for the same field
         // of type string so it should be mapped as a string
-        DocumentMapper newMapper = indexService.mapperService().documentMapperWithAutoCreate("type2").getDocumentMapper();
+        DocumentMapper newMapper = indexService.mapperService().documentMapperWithAutoCreate().getDocumentMapper();
         Mapper update = parse(newMapper, indexService.mapperService().documentMapperParser(),
-                XContentFactory.jsonBuilder().startObject()
-                    .field("my_field1", 42)
-                    .field("my_field2", 43)
-                    .field("my_field3", 44)
-                    .field("my_field4", 45)
-                    .field("my_field5", 46)
-                    .field("my_field6", Instant.now().toEpochMilli())
-                    .field("my_field7", true)
+            XContentFactory.jsonBuilder().startObject()
+                .field("my_field1", 42)
+                .field("my_field2", 43)
+                .field("my_field3", 44)
+                .field("my_field4", 45)
+                .field("my_field5", 46)
+                .field("my_field6", Instant.now().toEpochMilli())
+                .field("my_field7", true)
                 .endObject());
-        Mapper myField1Mapper = null;
-        Mapper myField2Mapper = null;
-        Mapper myField3Mapper = null;
-        Mapper myField4Mapper = null;
-        Mapper myField5Mapper = null;
-        Mapper myField6Mapper = null;
-        Mapper myField7Mapper = null;
-        for (Mapper m : update) {
-            switch (m.name()) {
-            case "my_field1":
-                myField1Mapper = m;
-                break;
-            case "my_field2":
-                myField2Mapper = m;
-                break;
-            case "my_field3":
-                myField3Mapper = m;
-                break;
-            case "my_field4":
-                myField4Mapper = m;
-                break;
-            case "my_field5":
-                myField5Mapper = m;
-                break;
-            case "my_field6":
-                myField6Mapper = m;
-                break;
-            case "my_field7":
-                myField7Mapper = m;
-                break;
-            }
-        }
-        assertNotNull(myField1Mapper);
-        // same type
-        assertTrue(myField1Mapper instanceof TextFieldMapper);
-        // and same option
-        assertTrue(((TextFieldMapper) myField1Mapper).fieldType().stored());
-
-        // Even if dynamic mappings would map a numeric field as a long, here it should map it as a integer
-        // since we already have a mapping of type integer
-        assertNotNull(myField2Mapper);
-        // same type
-        assertEquals("integer", ((FieldMapper) myField2Mapper).fieldType().typeName());
-        // and same option
-        assertFalse(((FieldMapper) myField2Mapper).fieldType().stored());
-
-        assertNotNull(myField3Mapper);
-        assertTrue(myField3Mapper instanceof NumberFieldMapper);
-        assertFalse(((NumberFieldType) ((NumberFieldMapper) myField3Mapper).fieldType()).hasDocValues());
-
-        assertNotNull(myField4Mapper);
-        assertTrue(myField4Mapper instanceof NumberFieldMapper);
-        assertEquals(IndexOptions.NONE, ((FieldMapper) myField4Mapper).fieldType().indexOptions());
-
-        assertNotNull(myField5Mapper);
-
-        assertTrue(myField5Mapper instanceof NumberFieldMapper);
-        assertTrue(((NumberFieldMapper) myField5Mapper).fieldType().stored());
-
-        assertNotNull(myField6Mapper);
-        assertTrue(myField6Mapper instanceof DateFieldMapper);
-        assertFalse(((DateFieldType) ((DateFieldMapper) myField6Mapper).fieldType()).hasDocValues());
-
-        assertNotNull(myField7Mapper);
-        assertTrue(myField7Mapper instanceof BooleanFieldMapper);
-        assertFalse(((BooleanFieldType) ((BooleanFieldMapper) myField7Mapper).fieldType()).hasDocValues());
-
-        // This can't work
-        try {
+        assertNull(update);
+
+        MapperParsingException e = expectThrows(MapperParsingException.class, () -> {
             parse(newMapper, indexService.mapperService().documentMapperParser(),
-                    XContentFactory.jsonBuilder().startObject().field("my_field2", "foobar").endObject());
-            fail("Cannot succeed, incompatible types");
-        } catch (MapperParsingException e) {
-            // expected
-        }
+                XContentFactory.jsonBuilder().startObject().field("my_field2", "foobar").endObject());
+        });
+        assertThat(e.getMessage(), containsString("failed to parse field [my_field2] of type [integer]"));
     }
 
     public void testMixTemplateMultiFieldAndMappingReuse() throws Exception {
@@ -563,14 +493,14 @@ public class DynamicMappingTests extends ESSingleNodeTestCase {
                     .field("field", "foo")
                 .endObject();
         SourceToParse source = new SourceToParse("test",  "1", BytesReference.bytes(json), json.contentType());
-        DocumentMapper mapper = indexService.mapperService().documentMapper("_doc");
+        DocumentMapper mapper = indexService.mapperService().documentMapper();
         assertNull(mapper.mappers().getMapper("field.raw"));
         ParsedDocument parsed = mapper.parse(source);
         assertNotNull(parsed.dynamicMappingsUpdate());
 
         indexService.mapperService().merge("_doc", new CompressedXContent(parsed.dynamicMappingsUpdate().toString()),
             MapperService.MergeReason.MAPPING_UPDATE);
-        mapper = indexService.mapperService().documentMapper("_doc");
+        mapper = indexService.mapperService().documentMapper();
         assertNotNull(mapper.mappers().getMapper("field.raw"));
         parsed = mapper.parse(source);
         assertNull(parsed.dynamicMappingsUpdate());
@@ -583,7 +513,7 @@ public class DynamicMappingTests extends ESSingleNodeTestCase {
                     .field("numeric_detection", true)
                 .endObject().endObject());
         mapperService.merge("type", new CompressedXContent(mapping), MapperService.MergeReason.MAPPING_UPDATE);
-        DocumentMapper mapper = mapperService.documentMapper("type");
+        DocumentMapper mapper = mapperService.documentMapper();
         doTestDefaultFloatingPointMappings(mapper, XContentFactory.jsonBuilder());
         doTestDefaultFloatingPointMappings(mapper, XContentFactory.yamlBuilder());
         doTestDefaultFloatingPointMappings(mapper, XContentFactory.smileBuilder());
@@ -614,7 +544,7 @@ public class DynamicMappingTests extends ESSingleNodeTestCase {
 
         IndexService index = createIndex("test");
         client().admin().indices().preparePutMapping("test").setType("type").setSource(mapping, XContentType.JSON).get();
-        DocumentMapper defaultMapper = index.mapperService().documentMapper("type");
+        DocumentMapper defaultMapper = index.mapperService().documentMapper();
 
         ParsedDocument doc = defaultMapper.parse(new SourceToParse("test", "1", BytesReference
                 .bytes(XContentFactory.jsonBuilder()
@@ -627,7 +557,7 @@ public class DynamicMappingTests extends ESSingleNodeTestCase {
         client().admin().indices().preparePutMapping("test").setType("type")
             .setSource(doc.dynamicMappingsUpdate().toString(), XContentType.JSON).get();
 
-        defaultMapper = index.mapperService().documentMapper("type");
+        defaultMapper = index.mapperService().documentMapper();
         Mapper mapper = defaultMapper.mappers().getMapper("s_long");
         assertThat(mapper.typeName(), equalTo("long"));
 
@@ -641,7 +571,7 @@ public class DynamicMappingTests extends ESSingleNodeTestCase {
 
         IndexService index = createIndex("test");
         client().admin().indices().preparePutMapping("test").setType("type").setSource(mapping, XContentType.JSON).get();
-        DocumentMapper defaultMapper = index.mapperService().documentMapper("type");
+        DocumentMapper defaultMapper = index.mapperService().documentMapper();
 
         ParsedDocument doc = defaultMapper.parse(new SourceToParse("test", "1", BytesReference
                 .bytes(XContentFactory.jsonBuilder()
@@ -654,7 +584,7 @@ public class DynamicMappingTests extends ESSingleNodeTestCase {
         assertAcked(client().admin().indices().preparePutMapping("test").setType("type")
             .setSource(doc.dynamicMappingsUpdate().toString(), XContentType.JSON).get());
 
-        defaultMapper = index.mapperService().documentMapper("type");
+        defaultMapper = index.mapperService().documentMapper();
         Mapper mapper = defaultMapper.mappers().getMapper("s_long");
         assertThat(mapper, instanceOf(TextFieldMapper.class));
 
@@ -690,7 +620,7 @@ public class DynamicMappingTests extends ESSingleNodeTestCase {
 
         IndexService index = createIndex("test");
         client().admin().indices().preparePutMapping("test").setType("type").setSource(mapping, XContentType.JSON).get();
-        DocumentMapper defaultMapper = index.mapperService().documentMapper("type");
+        DocumentMapper defaultMapper = index.mapperService().documentMapper();
 
         ParsedDocument doc = defaultMapper.parse(new SourceToParse("test", "1", BytesReference
                 .bytes(XContentFactory.jsonBuilder()
@@ -704,7 +634,7 @@ public class DynamicMappingTests extends ESSingleNodeTestCase {
         assertAcked(client().admin().indices().preparePutMapping("test").setType("type")
             .setSource(doc.dynamicMappingsUpdate().toString(), XContentType.JSON).get());
 
-        defaultMapper = index.mapperService().documentMapper("type");
+        defaultMapper = index.mapperService().documentMapper();
 
         DateFieldMapper dateMapper1 = (DateFieldMapper) defaultMapper.mappers().getMapper("date1");
         DateFieldMapper dateMapper2 = (DateFieldMapper) defaultMapper.mappers().getMapper("date2");

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

@@ -42,7 +42,7 @@ public class DynamicMappingVersionTests extends ESSingleNodeTestCase {
     public void testDynamicMappingDefault() throws IOException {
         MapperService mapperService = createIndex("my-index").mapperService();
         DocumentMapper documentMapper = mapperService
-            .documentMapperWithAutoCreate("my-type").getDocumentMapper();
+            .documentMapperWithAutoCreate().getDocumentMapper();
 
         ParsedDocument parsedDoc = documentMapper.parse(
             new SourceToParse("my-index", "1", BytesReference
@@ -52,7 +52,7 @@ public class DynamicMappingVersionTests extends ESSingleNodeTestCase {
                     .endObject()), XContentType.JSON));
 
         String expectedMapping = Strings.toString(XContentFactory.jsonBuilder().startObject()
-            .startObject("my-type")
+            .startObject("_doc")
             .startObject("properties")
             .startObject("foo").field("type", "long")
             .endObject().endObject().endObject().endObject());

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

@@ -47,7 +47,7 @@ public class DynamicTemplatesTests extends ESSingleNodeTestCase {
         client().admin().indices().preparePutMapping("test").setType("person").setSource(builder).get();
 
         MapperService mapperService = index.mapperService();
-        DocumentMapper docMapper = mapperService.documentMapper("person");
+        DocumentMapper docMapper = mapperService.documentMapper();
         builder = JsonXContent.contentBuilder();
         builder.startObject().field("s", "hello").field("l", 1).endObject();
         ParsedDocument parsedDoc = docMapper.parse(new SourceToParse("test", "1", BytesReference.bytes(builder),
@@ -66,13 +66,13 @@ public class DynamicTemplatesTests extends ESSingleNodeTestCase {
         String mapping = copyToStringFromClasspath("/org/elasticsearch/index/mapper/dynamictemplate/simple/test-mapping.json");
         IndexService index = createIndex("test");
         client().admin().indices().preparePutMapping("test").setType("person").setSource(mapping, XContentType.JSON).get();
-        DocumentMapper docMapper = index.mapperService().documentMapper("person");
+        DocumentMapper docMapper = index.mapperService().documentMapper();
         byte[] json = copyToBytesFromClasspath("/org/elasticsearch/index/mapper/dynamictemplate/simple/test-data.json");
         ParsedDocument parsedDoc = docMapper.parse(new SourceToParse("test", "1", new BytesArray(json),
                 XContentType.JSON));
         client().admin().indices().preparePutMapping("test").setType("person")
             .setSource(parsedDoc.dynamicMappingsUpdate().toString(), XContentType.JSON).get();
-        docMapper = index.mapperService().documentMapper("person");
+        docMapper = index.mapperService().documentMapper();
         Document doc = parsedDoc.rootDoc();
 
         IndexableField f = doc.getField("name");
@@ -125,13 +125,13 @@ public class DynamicTemplatesTests extends ESSingleNodeTestCase {
         String mapping = copyToStringFromClasspath("/org/elasticsearch/index/mapper/dynamictemplate/simple/test-mapping.json");
         IndexService index = createIndex("test");
         client().admin().indices().preparePutMapping("test").setType("person").setSource(mapping, XContentType.JSON).get();
-        DocumentMapper docMapper = index.mapperService().documentMapper("person");
+        DocumentMapper docMapper = index.mapperService().documentMapper();
         byte[] json = copyToBytesFromClasspath("/org/elasticsearch/index/mapper/dynamictemplate/simple/test-data.json");
         ParsedDocument parsedDoc = docMapper.parse(new SourceToParse("test", "1", new BytesArray(json),
                 XContentType.JSON));
         client().admin().indices().preparePutMapping("test").setType("person")
             .setSource(parsedDoc.dynamicMappingsUpdate().toString(), XContentType.JSON).get();
-        docMapper = index.mapperService().documentMapper("person");
+        docMapper = index.mapperService().documentMapper();
         Document doc = parsedDoc.rootDoc();
 
         IndexableField f = doc.getField("name");

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

@@ -77,7 +77,7 @@ public class UpdateMappingTests extends ESSingleNodeTestCase {
 
     protected void testConflictWhileMergingAndMappingUnchanged(XContentBuilder mapping, XContentBuilder mappingUpdate) throws IOException {
         IndexService indexService = createIndex("test", Settings.builder().build(), "type", mapping);
-        CompressedXContent mappingBeforeUpdate = indexService.mapperService().documentMapper("type").mappingSource();
+        CompressedXContent mappingBeforeUpdate = indexService.mapperService().documentMapper().mappingSource();
         // simulate like in MetaDataMappingService#putMapping
         try {
             indexService.mapperService().merge("type", new CompressedXContent(BytesReference.bytes(mappingUpdate)),
@@ -87,7 +87,7 @@ public class UpdateMappingTests extends ESSingleNodeTestCase {
             // expected
         }
         // make sure simulate flag actually worked - no mappings applied
-        CompressedXContent mappingAfterUpdate = indexService.mapperService().documentMapper("type").mappingSource();
+        CompressedXContent mappingAfterUpdate = indexService.mapperService().documentMapper().mappingSource();
         assertThat(mappingAfterUpdate, equalTo(mappingBeforeUpdate));
     }
 
@@ -115,7 +115,7 @@ public class UpdateMappingTests extends ESSingleNodeTestCase {
             assertThat(e.getMessage(), containsString("mapper [foo] cannot be changed from type [long] to [double]"));
         }
 
-        assertThat(((FieldMapper) mapperService.documentMapper("type").mapping().root().getMapper("foo")).fieldType().typeName(),
+        assertThat(((FieldMapper) mapperService.documentMapper().mapping().root().getMapper("foo")).fieldType().typeName(),
                 equalTo("long"));
     }
 
@@ -137,7 +137,7 @@ public class UpdateMappingTests extends ESSingleNodeTestCase {
             assertTrue(e.getMessage(), e.getMessage().contains("mapper [foo] cannot be changed from type [long] to [double]"));
         }
 
-        assertThat(((FieldMapper) mapperService.documentMapper("type").mapping().root().getMapper("foo")).fieldType().typeName(),
+        assertThat(((FieldMapper) mapperService.documentMapper().mapping().root().getMapper("foo")).fieldType().typeName(),
                 equalTo("long"));
     }
 

server/src/test/java/org/elasticsearch/search/geo/GeoShapeQueryTests.java

@@ -215,43 +215,6 @@ public class GeoShapeQueryTests extends ESSingleNodeTestCase {
         assertThat(searchResponse.getHits().getAt(0).getId(), equalTo("1"));
     }
 
-     public void testIndexedShapeReferenceWithTypes() throws Exception {
-        String mapping = Strings.toString(createMapping());
-        client().admin().indices().prepareCreate("test").addMapping("type1", mapping, XContentType.JSON).get();
-        createIndex("shapes");
-        ensureGreen();
-
-        EnvelopeBuilder shape = new EnvelopeBuilder(new Coordinate(-45, 45), new Coordinate(45, -45));
-
-        client().prepareIndex("shapes").setId("Big_Rectangle").setSource(jsonBuilder().startObject()
-                .field("shape", shape).endObject()).setRefreshPolicy(IMMEDIATE).get();
-        client().prepareIndex("test").setId("1").setSource(jsonBuilder().startObject()
-                .field("name", "Document 1")
-                .startObject("location")
-                .field("type", "point")
-                .startArray("coordinates").value(-30).value(-30).endArray()
-                .endObject()
-                .endObject()).setRefreshPolicy(IMMEDIATE).get();
-
-        SearchResponse searchResponse = client().prepareSearch("test")
-                .setQuery(geoIntersectionQuery("location", "Big_Rectangle"))
-                .get();
-
-        assertSearchResponse(searchResponse);
-        assertThat(searchResponse.getHits().getTotalHits().value, equalTo(1L));
-        assertThat(searchResponse.getHits().getHits().length, equalTo(1));
-        assertThat(searchResponse.getHits().getAt(0).getId(), equalTo("1"));
-
-        searchResponse = client().prepareSearch("test")
-                .setQuery(geoShapeQuery("location", "Big_Rectangle"))
-                .get();
-
-        assertSearchResponse(searchResponse);
-        assertThat(searchResponse.getHits().getTotalHits().value, equalTo(1L));
-        assertThat(searchResponse.getHits().getHits().length, equalTo(1));
-        assertThat(searchResponse.getHits().getAt(0).getId(), equalTo("1"));
-    }
-
     public void testIndexedShapeReferenceSourceDisabled() throws Exception {
         XContentBuilder mapping = createMapping();
         client().admin().indices().prepareCreate("test").addMapping("type1", mapping).get();
@@ -289,7 +252,7 @@ public class GeoShapeQueryTests extends ESSingleNodeTestCase {
 
     public void testShapeFetchingPath() throws Exception {
         createIndex("shapes");
-        client().admin().indices().prepareCreate("test").addMapping("type", "location", "type=geo_shape").get();
+        client().admin().indices().prepareCreate("test").addMapping("_doc", "location", "type=geo_shape").get();
 
         String location = "\"location\" : {\"type\":\"polygon\", \"coordinates\":[[[-10,-10],[10,-10],[10,10],[-10,10],[-10,-10]]]}";
 

x-pack/plugin/ccr/src/test/java/org/elasticsearch/xpack/ccr/FollowerFailOverIT.java

@@ -276,7 +276,7 @@ public class FollowerFailOverIT extends CcrIntegTestCase {
             // Make sure the mapping is ready on the shard before we execute the index request; otherwise the index request
             // will perform a dynamic mapping update which however will be blocked because the latch is remained closed.
             assertBusy(() -> {
-                DocumentMapper mapper = indexShard.mapperService().documentMapper("doc");
+                DocumentMapper mapper = indexShard.mapperService().documentMapper();
                 assertNotNull(mapper);
                 assertNotNull(mapper.mappers().getMapper("balance"));
             });

x-pack/plugin/core/src/test/java/org/elasticsearch/snapshots/SourceOnlySnapshotShardTests.java

@@ -263,7 +263,7 @@ public class SourceOnlySnapshotShardTests extends IndexShardTestCase {
             }
             expectThrows(UnsupportedOperationException.class, () -> searcher.search(new TermQuery(new Term("boom", "boom")), 1));
             targetShard = reindex(searcher.getDirectoryReader(), new MappingMetaData("_doc",
-                restoredShard.mapperService().documentMapper("_doc").meta()));
+                restoredShard.mapperService().documentMapper().meta()));
         }
 
         for (int i = 0; i < numInitialDocs; i++) {