mirrors
/
elasticsearch
mirror of https://mirror.osredm.com/root/elasticsearch.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Don't use user-supplied type when building DocumentMapper (#50960) 

This commit begins the process of removing types from the document parsing
infrastructure. Initially, we just ignore the user-supplied type after it has been
removed from the mapping json structure, and always supply _doc as the name
of the root parser.

The production code change is very small here, and most of the changeset
consists of alterations to Mapper test code that was passing in non-standard
type names and checking serialization.

Relates to #41059
This commit is contained in:
Alan Woodward 2020-01-14 15:15:19 +00:00 committed by GitHub
parent 58099122da
commit 774bfb5e22
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
28 changed files with 336 additions and 367 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -64,11 +64,11 @@ public class RankFeatureFieldMapperTests extends ESSingleNodeTestCase {
}
public void testDefaults() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "rank_feature").endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -99,12 +99,12 @@ public class RankFeatureFieldMapperTests extends ESSingleNodeTestCase {
}
public void testNegativeScoreImpact() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "rank_feature")
.field("positive_score_impact", false).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -135,12 +135,12 @@ public class RankFeatureFieldMapperTests extends ESSingleNodeTestCase {
}
public void testRejectMultiValuedFields() throws MapperParsingException, IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "rank_feature").endObject().startObject("foo")
.startObject("properties").startObject("field").field("type", "rank_feature").endObject().endObject()
.endObject().endObject().endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());

6
modules/mapper-extras/src/test/java/org/elasticsearch/index/mapper/RankFeatureMetaFieldMapperTests.java
View File

@ -44,13 +44,13 @@ public class RankFeatureMetaFieldMapperTests extends ESSingleNodeTestCase {
protected Collection<Class<? extends Plugin>> getPlugins() {
return pluginList(MapperExtrasPlugin.class);
}
public void testBasics() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "rank_feature").endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
assertNotNull(mapper.metadataMapper(RankFeatureMetaFieldMapper.class));

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

@ -53,11 +53,11 @@ public class RankFeaturesFieldMapperTests extends ESSingleNodeTestCase {
}
public void testDefaults() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "rank_features").endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -85,12 +85,12 @@ public class RankFeaturesFieldMapperTests extends ESSingleNodeTestCase {
}
public void testRejectMultiValuedFields() throws MapperParsingException, IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "rank_features").endObject().startObject("foo")
.startObject("properties").startObject("field").field("type", "rank_features").endObject().endObject()
.endObject().endObject().endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());

40
modules/mapper-extras/src/test/java/org/elasticsearch/index/mapper/ScaledFloatFieldMapperTests.java
View File

@ -58,12 +58,12 @@ public class ScaledFloatFieldMapperTests extends ESSingleNodeTestCase {
}
public void testDefaults() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "scaled_float")
.field("scaling_factor", 10.0).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -108,12 +108,12 @@ public class ScaledFloatFieldMapperTests extends ESSingleNodeTestCase {
}
public void testNotIndexed() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "scaled_float")
.field("index", false).field("scaling_factor", 10.0).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -132,12 +132,12 @@ public class ScaledFloatFieldMapperTests extends ESSingleNodeTestCase {
}
public void testNoDocValues() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "scaled_float")
.field("doc_values", false).field("scaling_factor", 10.0).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -156,12 +156,12 @@ public class ScaledFloatFieldMapperTests extends ESSingleNodeTestCase {
}
public void testStore() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "scaled_float")
.field("store", true).field("scaling_factor", 10.0).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -185,12 +185,12 @@ public class ScaledFloatFieldMapperTests extends ESSingleNodeTestCase {
}
public void testCoerce() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "scaled_float")
.field("scaling_factor", 10.0).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -209,12 +209,12 @@ public class ScaledFloatFieldMapperTests extends ESSingleNodeTestCase {
IndexableField dvField = fields[1];
assertEquals(DocValuesType.SORTED_NUMERIC, dvField.fieldType().docValuesType());
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "scaled_float")
.field("scaling_factor", 10.0).field("coerce", false).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper2 = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper2 = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper2.mappingSource().toString());
@ -238,12 +238,12 @@ public class ScaledFloatFieldMapperTests extends ESSingleNodeTestCase {
}
private void doTestIgnoreMalformed(String value, String exceptionMessageContains) throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "scaled_float")
.field("scaling_factor", 10.0).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -256,12 +256,12 @@ public class ScaledFloatFieldMapperTests extends ESSingleNodeTestCase {
MapperParsingException e = expectThrows(MapperParsingException.class, runnable);
assertThat(e.getCause().getMessage(), containsString(exceptionMessageContains));
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "scaled_float")
.field("scaling_factor", 10.0).field("ignore_malformed", true).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper2 = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper2 = parser.parse("_doc", new CompressedXContent(mapping));
ParsedDocument doc = mapper2.parse(new SourceToParse("test", "1", BytesReference
.bytes(XContentFactory.jsonBuilder()
@ -276,7 +276,7 @@ public class ScaledFloatFieldMapperTests extends ESSingleNodeTestCase {
public void testNullValue() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject()
.startObject("type")
.startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", "scaled_float")
@ -285,7 +285,7 @@ public class ScaledFloatFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
ParsedDocument doc = mapper.parse(new SourceToParse("test", "1", BytesReference
@ -297,7 +297,7 @@ public class ScaledFloatFieldMapperTests extends ESSingleNodeTestCase {
assertArrayEquals(new IndexableField[0], doc.rootDoc().getFields("field"));
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject()
.startObject("type")
.startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", "scaled_float")
@ -307,7 +307,7 @@ public class ScaledFloatFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject().endObject());
mapper = parser.parse("type", new CompressedXContent(mapping));
mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
doc = mapper.parse(new SourceToParse("test", "1", BytesReference

44
plugins/analysis-icu/src/test/java/org/elasticsearch/index/mapper/ICUCollationKeywordFieldMapperTests.java
View File

@ -64,11 +64,11 @@ public class ICUCollationKeywordFieldMapperTests extends ESSingleNodeTestCase {
}
public void testDefaults() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", FIELD_TYPE).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -105,11 +105,11 @@ public class ICUCollationKeywordFieldMapperTests extends ESSingleNodeTestCase {
}
public void testNullValue() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", FIELD_TYPE).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
ParsedDocument doc = mapper.parse(new SourceToParse("test", "1", BytesReference
@ -120,12 +120,12 @@ public class ICUCollationKeywordFieldMapperTests extends ESSingleNodeTestCase {
XContentType.JSON));
assertArrayEquals(new IndexableField[0], doc.rootDoc().getFields("field"));
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", FIELD_TYPE)
.field("null_value", "1234").endObject().endObject()
.endObject().endObject());
mapper = parser.parse("type", new CompressedXContent(mapping));
mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -155,12 +155,12 @@ public class ICUCollationKeywordFieldMapperTests extends ESSingleNodeTestCase {
}
public void testEnableStore() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", FIELD_TYPE)
.field("store", true).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -177,12 +177,12 @@ public class ICUCollationKeywordFieldMapperTests extends ESSingleNodeTestCase {
}
public void testDisableIndex() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", FIELD_TYPE)
.field("index", false).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -200,12 +200,12 @@ public class ICUCollationKeywordFieldMapperTests extends ESSingleNodeTestCase {
}
public void testDisableDocValues() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", FIELD_TYPE)
.field("doc_values", false).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -222,11 +222,11 @@ public class ICUCollationKeywordFieldMapperTests extends ESSingleNodeTestCase {
}
public void testMultipleValues() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", FIELD_TYPE).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -284,12 +284,12 @@ public class ICUCollationKeywordFieldMapperTests extends ESSingleNodeTestCase {
}
public void testIndexOptions() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", FIELD_TYPE)
.field("index_options", "freqs").endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -317,12 +317,12 @@ public class ICUCollationKeywordFieldMapperTests extends ESSingleNodeTestCase {
}
public void testEnableNorms() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", FIELD_TYPE)
.field("norms", true).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -339,14 +339,14 @@ public class ICUCollationKeywordFieldMapperTests extends ESSingleNodeTestCase {
}
public void testCollator() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field")
.field("type", FIELD_TYPE)
.field("language", "tr")
.field("strength", "primary")
.endObject().endObject().endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -406,12 +406,12 @@ public class ICUCollationKeywordFieldMapperTests extends ESSingleNodeTestCase {
public void testIgnoreAbove() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", FIELD_TYPE)
.field("ignore_above", 5).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());

48
plugins/mapper-annotated-text/src/test/java/org/elasticsearch/index/mapper/annotatedtext/AnnotatedTextFieldMapperTests.java
View File

@ -252,11 +252,11 @@ public class AnnotatedTextFieldMapperTests extends ESSingleNodeTestCase {
// ===== Code below copied from TextFieldMapperTests ========
public void testDefaults() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", getFieldType()).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -284,11 +284,11 @@ public class AnnotatedTextFieldMapperTests extends ESSingleNodeTestCase {
}
public void testEnableStore() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", getFieldType()).field("store", true).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -305,14 +305,14 @@ public class AnnotatedTextFieldMapperTests extends ESSingleNodeTestCase {
}
public void testDisableNorms() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field")
.field("type", getFieldType())
.field("norms", false)
.endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -360,11 +360,11 @@ public class AnnotatedTextFieldMapperTests extends ESSingleNodeTestCase {
}
public void testDefaultPositionIncrementGap() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", getFieldType()).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = indexService.mapperService().merge("type",
DocumentMapper mapper = indexService.mapperService().merge("_doc",
new CompressedXContent(mapping), MergeReason.MAPPING_UPDATE);
assertEquals(mapping, mapper.mappingSource().toString());
@ -399,14 +399,14 @@ public class AnnotatedTextFieldMapperTests extends ESSingleNodeTestCase {
public void testPositionIncrementGap() throws IOException {
final int positionIncrementGap = randomIntBetween(1, 1000);
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field")
.field("type", getFieldType())
.field("position_increment_gap", positionIncrementGap)
.endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = indexService.mapperService().merge("type",
DocumentMapper mapper = indexService.mapperService().merge("_doc",
new CompressedXContent(mapping), MergeReason.MAPPING_UPDATE);
assertEquals(mapping, mapper.mappingSource().toString());
@ -440,7 +440,7 @@ public class AnnotatedTextFieldMapperTests extends ESSingleNodeTestCase {
}
public void testSearchAnalyzerSerialization() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", getFieldType())
@ -449,11 +449,11 @@ public class AnnotatedTextFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject().endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
// special case: default index analyzer
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", getFieldType())
@ -462,10 +462,10 @@ public class AnnotatedTextFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject().endObject().endObject());
mapper = parser.parse("type", new CompressedXContent(mapping));
mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", getFieldType())
@ -473,11 +473,11 @@ public class AnnotatedTextFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject().endObject().endObject());
mapper = parser.parse("type", new CompressedXContent(mapping));
mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
// special case: default search analyzer
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", getFieldType())
@ -486,17 +486,17 @@ public class AnnotatedTextFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject().endObject().endObject());
mapper = parser.parse("type", new CompressedXContent(mapping));
mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", getFieldType())
.field("analyzer", "keyword")
.endObject()
.endObject().endObject().endObject());
mapper = parser.parse("type", new CompressedXContent(mapping));
mapper = parser.parse("_doc", new CompressedXContent(mapping));
XContentBuilder builder = XContentFactory.jsonBuilder();
builder.startObject();
@ -510,7 +510,7 @@ public class AnnotatedTextFieldMapperTests extends ESSingleNodeTestCase {
}
public void testSearchQuoteAnalyzerSerialization() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", getFieldType())
@ -520,11 +520,11 @@ public class AnnotatedTextFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject().endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
// special case: default index/search analyzer
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", getFieldType())
@ -534,7 +534,7 @@ public class AnnotatedTextFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject().endObject().endObject());
mapper = parser.parse("type", new CompressedXContent(mapping));
mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
}

11
server/src/main/java/org/elasticsearch/index/mapper/DocumentMapperParser.java
View File

@ -74,25 +74,22 @@ public class DocumentMapperParser {
if (source != null) {
Map<String, Object> root = XContentHelper.convertToMap(source.compressedReference(), true, XContentType.JSON).v2();
Tuple<String, Map<String, Object>> t = extractMapping(type, root);
type = t.v1();
mapping = t.v2();
}
if (mapping == null) {
mapping = new HashMap<>();
}
return parse(type, mapping);
return parse(mapping);
}
@SuppressWarnings({"unchecked"})
private DocumentMapper parse(String type, Map<String, Object> mapping) throws MapperParsingException {
if (type == null) {
throw new MapperParsingException("Failed to derive type");
}
private DocumentMapper parse(Map<String, Object> mapping) throws MapperParsingException {
Mapper.TypeParser.ParserContext parserContext = parserContext();
// parse RootObjectMapper
DocumentMapper.Builder docBuilder = new DocumentMapper.Builder(
(RootObjectMapper.Builder) rootObjectTypeParser.parse(type, mapping, parserContext), mapperService);
(RootObjectMapper.Builder) rootObjectTypeParser.parse(MapperService.SINGLE_MAPPING_NAME, mapping, parserContext),
mapperService);
Iterator<Map.Entry<String, Object>> iterator = mapping.entrySet().iterator();
// parse DocumentMapper
while(iterator.hasNext()) {

4
server/src/test/java/org/elasticsearch/index/mapper/BooleanFieldMapperTests.java
View File

@ -180,7 +180,7 @@ public class BooleanFieldMapperTests extends ESSingleNodeTestCase {
public void testMultiFields() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", "boolean")
@ -192,7 +192,7 @@ public class BooleanFieldMapperTests extends ESSingleNodeTestCase {
.endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = indexService.mapperService()
.merge("type", new CompressedXContent(mapping), MapperService.MergeReason.MAPPING_UPDATE);
.merge("_doc", new CompressedXContent(mapping), MapperService.MergeReason.MAPPING_UPDATE);
assertEquals(mapping, mapper.mappingSource().toString());
BytesReference source = BytesReference.bytes(XContentFactory.jsonBuilder()
.startObject()

6
server/src/test/java/org/elasticsearch/index/mapper/CopyToMapperTests.java
View File

@ -232,7 +232,7 @@ public class CopyToMapperTests extends ESSingleNodeTestCase {
}
public void testCopyToStrictDynamicInnerObjectParsing() throws Exception {
String mapping = Strings.toString(jsonBuilder().startObject().startObject("type1")
String mapping = Strings.toString(jsonBuilder().startObject().startObject("_doc")
.field("dynamic", "strict")
.startObject("properties")
.startObject("copy_test")
@ -243,7 +243,7 @@ public class CopyToMapperTests extends ESSingleNodeTestCase {
.endObject().endObject());
DocumentMapper docMapper = createIndex("test").mapperService().documentMapperParser()
.parse("type1", new CompressedXContent(mapping));
.parse("_doc", new CompressedXContent(mapping));
BytesReference json = BytesReference.bytes(jsonBuilder().startObject()
.field("copy_test", "foo")
@ -253,7 +253,7 @@ public class CopyToMapperTests extends ESSingleNodeTestCase {
docMapper.parse(new SourceToParse("test", "1", json, XContentType.JSON)).rootDoc();
fail();
} catch (MapperParsingException ex) {
assertThat(ex.getMessage(), startsWith("mapping set to strict, dynamic introduction of [very] within [type1] is not allowed"));
assertThat(ex.getMessage(), startsWith("mapping set to strict, dynamic introduction of [very] within [_doc] is not allowed"));
}
}

40
server/src/test/java/org/elasticsearch/index/mapper/DateFieldMapperTests.java
View File

@ -62,11 +62,11 @@ public class DateFieldMapperTests extends ESSingleNodeTestCase {
}
public void testDefaults() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "date").endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -91,11 +91,11 @@ public class DateFieldMapperTests extends ESSingleNodeTestCase {
}
public void testNotIndexed() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "date").field("index", false).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -113,11 +113,11 @@ public class DateFieldMapperTests extends ESSingleNodeTestCase {
}
public void testNoDocValues() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "date").field("doc_values", false).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -135,11 +135,11 @@ public class DateFieldMapperTests extends ESSingleNodeTestCase {
}
public void testStore() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "date").field("store", true).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -169,11 +169,11 @@ public class DateFieldMapperTests extends ESSingleNodeTestCase {
}
private void testIgnoreMalfomedForValue(String value, String expectedException) throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "date").endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -206,12 +206,12 @@ public class DateFieldMapperTests extends ESSingleNodeTestCase {
}
public void testChangeFormat() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "date")
.field("format", "epoch_second").endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -230,13 +230,13 @@ public class DateFieldMapperTests extends ESSingleNodeTestCase {
public void testChangeLocale() throws IOException {
assumeTrue("need java 9 for testing ",JavaVersion.current().compareTo(JavaVersion.parse("9")) >= 0);
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "date")
.field("format", "E, d MMM yyyy HH:mm:ss Z")
.field("locale", "de")
.endObject().endObject().endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -250,7 +250,7 @@ public class DateFieldMapperTests extends ESSingleNodeTestCase {
public void testNullValue() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject()
.startObject("type")
.startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", "date")
@ -258,7 +258,7 @@ public class DateFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
ParsedDocument doc = mapper.parse(new SourceToParse("test", "1", BytesReference
@ -270,7 +270,7 @@ public class DateFieldMapperTests extends ESSingleNodeTestCase {
assertArrayEquals(new IndexableField[0], doc.rootDoc().getFields("field"));
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject()
.startObject("type")
.startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", "date")
@ -279,7 +279,7 @@ public class DateFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject().endObject());
mapper = parser.parse("type", new CompressedXContent(mapping));
mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
doc = mapper.parse(new SourceToParse("test", "1", BytesReference
@ -332,7 +332,7 @@ public class DateFieldMapperTests extends ESSingleNodeTestCase {
final String timeZonePattern = "yyyy-MM-dd" + randomFrom("XXX", "[XXX]", "'['XXX']'");
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject()
.startObject("type")
.startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", "date")
@ -341,7 +341,7 @@ public class DateFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
DateFormatter formatter = DateFormatter.forPattern(timeZonePattern);

10
server/src/test/java/org/elasticsearch/index/mapper/DocumentMapperParserTests.java
View File

@ -25,17 +25,7 @@ import org.elasticsearch.common.xcontent.XContentFactory;
import org.elasticsearch.index.IndexService;
import org.elasticsearch.test.ESSingleNodeTestCase;
import static org.hamcrest.Matchers.equalTo;
public class DocumentMapperParserTests extends ESSingleNodeTestCase {
public void testTypeLevel() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
.endObject().endObject());
DocumentMapperParser parser = createIndex("test").mapperService().documentMapperParser();
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
assertThat(mapper.type(), equalTo("type"));
}
public void testFieldNameWithDots() throws Exception {
IndexService indexService = createIndex("test");

4
server/src/test/java/org/elasticsearch/index/mapper/DocumentMapperTests.java
View File

@ -155,7 +155,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);
mapperService.merge("_doc", new CompressedXContent("{\"_doc\":{}}"), MapperService.MergeReason.MAPPING_UPDATE);
final DocumentMapper documentMapper = mapperService.documentMapper();
DocumentFieldMappers dfm = documentMapper.mappers();
@ -184,7 +184,7 @@ public class DocumentMapperTests extends ESSingleNodeTestCase {
Mapping update = doc.dynamicMappingsUpdate();
assert update != null;
lastIntroducedFieldName.set(fieldName);
mapperService.merge("test", new CompressedXContent(update.toString()), MapperService.MergeReason.MAPPING_UPDATE);
mapperService.merge("_doc", new CompressedXContent(update.toString()), MapperService.MergeReason.MAPPING_UPDATE);
}
} catch (Exception e) {
error.set(e);

18
server/src/test/java/org/elasticsearch/index/mapper/DocumentParserTests.java
View File

@ -549,7 +549,7 @@ public class DocumentParserTests extends ESSingleNodeTestCase {
.endArray().endObject());
StrictDynamicMappingException exception = expectThrows(StrictDynamicMappingException.class,
() -> mapper.parse(new SourceToParse("test", "1", bytes, XContentType.JSON)));
assertEquals("mapping set to strict, dynamic introduction of [foo] within [type] is not allowed", exception.getMessage());
assertEquals("mapping set to strict, dynamic introduction of [foo] within [_doc] is not allowed", exception.getMessage());
}
public void testMappedGeoPointArray() throws Exception {
@ -631,7 +631,7 @@ public class DocumentParserTests extends ESSingleNodeTestCase {
.endObject().endObject());
StrictDynamicMappingException exception = expectThrows(StrictDynamicMappingException.class,
() -> mapper.parse(new SourceToParse("test", "1", bytes, XContentType.JSON)));
assertEquals("mapping set to strict, dynamic introduction of [foo] within [type] is not allowed", exception.getMessage());
assertEquals("mapping set to strict, dynamic introduction of [foo] within [_doc] is not allowed", exception.getMessage());
}
public void testDynamicFalseValue() throws Exception {
@ -662,7 +662,7 @@ public class DocumentParserTests extends ESSingleNodeTestCase {
.endObject());
StrictDynamicMappingException exception = expectThrows(StrictDynamicMappingException.class,
() -> mapper.parse(new SourceToParse("test", "1", bytes, XContentType.JSON)));
assertEquals("mapping set to strict, dynamic introduction of [bar] within [type] is not allowed", exception.getMessage());
assertEquals("mapping set to strict, dynamic introduction of [bar] within [_doc] is not allowed", exception.getMessage());
}
public void testDynamicFalseNull() throws Exception {
@ -693,7 +693,7 @@ public class DocumentParserTests extends ESSingleNodeTestCase {
.endObject());
StrictDynamicMappingException exception = expectThrows(StrictDynamicMappingException.class,
() -> mapper.parse(new SourceToParse("test", "1", bytes, XContentType.JSON)));
assertEquals("mapping set to strict, dynamic introduction of [bar] within [type] is not allowed", exception.getMessage());
assertEquals("mapping set to strict, dynamic introduction of [bar] within [_doc] is not allowed", exception.getMessage());
}
public void testMappedNullValue() throws Exception {
@ -892,7 +892,7 @@ public class DocumentParserTests extends ESSingleNodeTestCase {
.endArray().endObject());
StrictDynamicMappingException exception = expectThrows(StrictDynamicMappingException.class,
() -> mapper.parse(new SourceToParse("test", "1", bytes, XContentType.JSON)));
assertEquals("mapping set to strict, dynamic introduction of [foo] within [type] is not allowed", exception.getMessage());
assertEquals("mapping set to strict, dynamic introduction of [foo] within [_doc] is not allowed", exception.getMessage());
}
public void testDynamicDottedFieldNameLong() throws Exception {
@ -1009,7 +1009,7 @@ public class DocumentParserTests extends ESSingleNodeTestCase {
.endObject());
StrictDynamicMappingException exception = expectThrows(StrictDynamicMappingException.class,
() -> mapper.parse(new SourceToParse("test", "1", bytes, XContentType.JSON)));
assertEquals("mapping set to strict, dynamic introduction of [foo] within [type] is not allowed", exception.getMessage());
assertEquals("mapping set to strict, dynamic introduction of [foo] within [_doc] is not allowed", exception.getMessage());
}
public void testDynamicDottedFieldNameObject() throws Exception {
@ -1136,7 +1136,7 @@ public class DocumentParserTests extends ESSingleNodeTestCase {
.endObject().endObject());
StrictDynamicMappingException exception = expectThrows(StrictDynamicMappingException.class,
() -> mapper.parse(new SourceToParse("test", "1", bytes, XContentType.JSON)));
assertEquals("mapping set to strict, dynamic introduction of [foo] within [type] is not allowed", exception.getMessage());
assertEquals("mapping set to strict, dynamic introduction of [foo] within [_doc] is not allowed", exception.getMessage());
}
public void testDocumentContainsMetadataField() throws Exception {
@ -1175,7 +1175,7 @@ public class DocumentParserTests extends ESSingleNodeTestCase {
DocumentMapper docMapper = parser.parse("person", new CompressedXContent(mapping));
String builtMapping = docMapper.mappingSource().string();
// reparse it
DocumentMapper builtDocMapper = parser.parse("person", new CompressedXContent(builtMapping));
DocumentMapper builtDocMapper = parser.parse("_doc", new CompressedXContent(builtMapping));
BytesReference json = new BytesArray(copyToBytesFromClasspath("/org/elasticsearch/index/mapper/simple/test1.json"));
Document doc = builtDocMapper.parse(new SourceToParse("test", "1", json, XContentType.JSON)).rootDoc();
assertThat(doc.getBinaryValue(docMapper.idFieldMapper().name()), equalTo(Uid.encodeId("1")));
@ -1213,7 +1213,7 @@ public class DocumentParserTests extends ESSingleNodeTestCase {
assertThat((String) docMapper.meta().get("param1"), equalTo("value1"));
String builtMapping = docMapper.mappingSource().string();
DocumentMapper builtDocMapper = parser.parse("person", new CompressedXContent(builtMapping));
DocumentMapper builtDocMapper = parser.parse("_doc", new CompressedXContent(builtMapping));
assertThat((String) builtDocMapper.meta().get("param1"), equalTo("value1"));
}

46
server/src/test/java/org/elasticsearch/index/mapper/DynamicMappingTests.java
View File

@ -123,7 +123,7 @@ public class DynamicMappingTests extends ESSingleNodeTestCase {
.field("field2", "value2")
.endObject()),
XContentType.JSON)));
assertThat(e.getMessage(), equalTo("mapping set to strict, dynamic introduction of [field2] within [type] is not allowed"));
assertThat(e.getMessage(), equalTo("mapping set to strict, dynamic introduction of [field2] within [_doc] is not allowed"));
e = expectThrows(StrictDynamicMappingException.class,
() -> defaultMapper.parse(new SourceToParse("test", "1",
@ -133,7 +133,7 @@ public class DynamicMappingTests extends ESSingleNodeTestCase {
.field("field2", (String) null)
.endObject()),
XContentType.JSON)));
assertThat(e.getMessage(), equalTo("mapping set to strict, dynamic introduction of [field2] within [type] is not allowed"));
assertThat(e.getMessage(), equalTo("mapping set to strict, dynamic introduction of [field2] within [_doc] is not allowed"));
}
public void testDynamicFalseWithInnerObjectButDynamicSetOnRoot() throws IOException {
@ -234,10 +234,10 @@ public class DynamicMappingTests extends ESSingleNodeTestCase {
IndexService indexService = createIndex("test");
DocumentMapperParser parser = indexService.mapperService().documentMapperParser();
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject()
.startObject("type").endObject()
.startObject("_doc").endObject()
.endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, serialize(mapper));
Mapper update = parse(mapper, parser, XContentFactory.jsonBuilder().startObject().field("foo", "bar").endObject());
@ -245,7 +245,7 @@ public class DynamicMappingTests extends ESSingleNodeTestCase {
// original mapping not modified
assertEquals(mapping, serialize(mapper));
// but we have an update
assertEquals(Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type").startObject("properties")
assertEquals(Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc").startObject("properties")
.startObject("foo")
.field("type", "text")
.startObject("fields")
@ -263,11 +263,11 @@ public class DynamicMappingTests extends ESSingleNodeTestCase {
DocumentMapperParser parser = indexService.mapperService().documentMapperParser();
// Make sure that mapping updates are incremental, this is important for performance otherwise
// every new field introduction runs in linear time with the total number of fields
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("foo").field("type", "text").endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, serialize(mapper));
Mapper update = parse(mapper, parser, XContentFactory.jsonBuilder().startObject().field("foo", "bar")
@ -276,7 +276,7 @@ public class DynamicMappingTests extends ESSingleNodeTestCase {
// original mapping not modified
assertEquals(mapping, serialize(mapper));
// but we have an update
assertEquals(Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type").startObject("properties")
assertEquals(Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc").startObject("properties")
// foo is NOT in the update
.startObject("bar").field("type", "text")
.startObject("fields")
@ -293,10 +293,10 @@ public class DynamicMappingTests extends ESSingleNodeTestCase {
IndexService indexService = createIndex("test");
DocumentMapperParser parser = indexService.mapperService().documentMapperParser();
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject()
.startObject("type").endObject()
.startObject("_doc").endObject()
.endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, serialize(mapper));
Mapper update = parse(mapper, parser, XContentFactory.jsonBuilder().startObject().field("foo", "bar")
@ -305,7 +305,7 @@ public class DynamicMappingTests extends ESSingleNodeTestCase {
// original mapping not modified
assertEquals(mapping, serialize(mapper));
// but we have an update
assertEquals(Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type").startObject("properties")
assertEquals(Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc").startObject("properties")
.startObject("bar").field("type", "text")
.startObject("fields")
.startObject("keyword")
@ -329,10 +329,10 @@ public class DynamicMappingTests extends ESSingleNodeTestCase {
IndexService indexService = createIndex("test");
DocumentMapperParser parser = indexService.mapperService().documentMapperParser();
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject()
.startObject("type").endObject()
.startObject("_doc").endObject()
.endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, serialize(mapper));
Mapper update = parse(mapper, parser, XContentFactory.jsonBuilder().startObject().startObject("foo").startObject("bar")
@ -341,7 +341,7 @@ public class DynamicMappingTests extends ESSingleNodeTestCase {
// original mapping not modified
assertEquals(mapping, serialize(mapper));
// but we have an update
assertEquals(Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type").startObject("properties")
assertEquals(Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc").startObject("properties")
.startObject("foo").startObject("properties").startObject("bar").startObject("properties").startObject("baz")
.field("type", "text")
.startObject("fields").startObject("keyword").field("type", "keyword")
@ -354,10 +354,10 @@ public class DynamicMappingTests extends ESSingleNodeTestCase {
IndexService indexService = createIndex("test");
DocumentMapperParser parser = indexService.mapperService().documentMapperParser();
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject()
.startObject("type").endObject()
.startObject("_doc").endObject()
.endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, serialize(mapper));
Mapper update = parse(mapper, parser, XContentFactory.jsonBuilder().startObject()
@ -366,7 +366,7 @@ public class DynamicMappingTests extends ESSingleNodeTestCase {
// original mapping not modified
assertEquals(mapping, serialize(mapper));
// but we have an update
assertEquals(Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type").startObject("properties")
assertEquals(Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc").startObject("properties")
.startObject("foo")
.field("type", "text")
.startObject("fields")
@ -382,11 +382,11 @@ public class DynamicMappingTests extends ESSingleNodeTestCase {
public void testInnerDynamicMapping() throws Exception {
IndexService indexService = createIndex("test");
DocumentMapperParser parser = indexService.mapperService().documentMapperParser();
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type") .startObject("properties")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc") .startObject("properties")
.startObject("foo").field("type", "object").endObject()
.endObject().endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, serialize(mapper));
Mapper update = parse(mapper, parser, XContentFactory.jsonBuilder().startObject().startObject("foo")
@ -395,7 +395,7 @@ public class DynamicMappingTests extends ESSingleNodeTestCase {
// original mapping not modified
assertEquals(mapping, serialize(mapper));
// but we have an update
assertEquals(Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type").startObject("properties")
assertEquals(Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc").startObject("properties")
.startObject("foo").startObject("properties").startObject("bar").startObject("properties")
.startObject("baz").field("type", "text").startObject("fields")
.startObject("keyword").field("type", "keyword").field("ignore_above", 256).endObject()
@ -407,10 +407,10 @@ public class DynamicMappingTests extends ESSingleNodeTestCase {
IndexService indexService = createIndex("test");
DocumentMapperParser parser = indexService.mapperService().documentMapperParser();
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject()
.startObject("type").endObject()
.startObject("_doc").endObject()
.endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, serialize(mapper));
Mapper update = parse(mapper, parser, XContentFactory.jsonBuilder().startObject().startArray("foo")
@ -418,7 +418,7 @@ public class DynamicMappingTests extends ESSingleNodeTestCase {
.startObject().field("baz", 3).endObject()
.endArray().endObject());
assertEquals(mapping, serialize(mapper));
assertEquals(Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type").startObject("properties")
assertEquals(Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc").startObject("properties")
.startObject("foo").startObject("properties")
.startObject("bar").field("type", "text")
.startObject("fields")

4
server/src/test/java/org/elasticsearch/index/mapper/FieldAliasMapperTests.java
View File

@ -43,7 +43,7 @@ public class FieldAliasMapperTests extends ESSingleNodeTestCase {
public void testParsing() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.startObject("_doc")
.startObject("properties")
.startObject("alias-field")
.field("type", "alias")
@ -55,7 +55,7 @@ public class FieldAliasMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject()
.endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
}

28
server/src/test/java/org/elasticsearch/index/mapper/IpFieldMapperTests.java
View File

@ -60,11 +60,11 @@ public class IpFieldMapperTests extends ESSingleNodeTestCase {
}
public void testDefaults() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "ip").endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -89,11 +89,11 @@ public class IpFieldMapperTests extends ESSingleNodeTestCase {
}
public void testNotIndexed() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "ip").field("index", false).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -111,11 +111,11 @@ public class IpFieldMapperTests extends ESSingleNodeTestCase {
}
public void testNoDocValues() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "ip").field("doc_values", false).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -134,11 +134,11 @@ public class IpFieldMapperTests extends ESSingleNodeTestCase {
}
public void testStore() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "ip").field("store", true).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -162,11 +162,11 @@ public class IpFieldMapperTests extends ESSingleNodeTestCase {
}
public void testIgnoreMalformed() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "ip").endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -199,7 +199,7 @@ public class IpFieldMapperTests extends ESSingleNodeTestCase {
public void testNullValue() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject()
.startObject("type")
.startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", "ip")
@ -207,7 +207,7 @@ public class IpFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
ParsedDocument doc = mapper.parse(new SourceToParse("test", "1", BytesReference
@ -219,7 +219,7 @@ public class IpFieldMapperTests extends ESSingleNodeTestCase {
assertArrayEquals(new IndexableField[0], doc.rootDoc().getFields("field"));
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject()
.startObject("type")
.startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", "ip")
@ -228,7 +228,7 @@ public class IpFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject().endObject());
mapper = parser.parse("type", new CompressedXContent(mapping));
mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
doc = mapper.parse(new SourceToParse("test", "1", BytesReference

4
server/src/test/java/org/elasticsearch/index/mapper/IpRangeFieldMapperTests.java
View File

@ -48,11 +48,11 @@ public class IpRangeFieldMapperTests extends ESSingleNodeTestCase {
}
public void testStoreCidr() throws Exception {
XContentBuilder mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
XContentBuilder mapping = XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "ip_range")
.field("store", true);
mapping = mapping.endObject().endObject().endObject().endObject();
DocumentMapper mapper = parser.parse("type", new CompressedXContent(Strings.toString(mapping)));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(Strings.toString(mapping)));
assertEquals(Strings.toString(mapping), mapper.mappingSource().toString());
final Map<String, String> cases = new HashMap<>();
cases.put("192.168.0.0/15", "192.169.255.255");

44
server/src/test/java/org/elasticsearch/index/mapper/KeywordFieldMapperTests.java
View File

@ -94,11 +94,11 @@ public class KeywordFieldMapperTests extends ESSingleNodeTestCase {
}
public void testDefaults() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "keyword").endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -131,11 +131,11 @@ public class KeywordFieldMapperTests extends ESSingleNodeTestCase {
}
public void testIgnoreAbove() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "keyword").field("ignore_above", 5).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -161,11 +161,11 @@ public class KeywordFieldMapperTests extends ESSingleNodeTestCase {
}
public void testNullValue() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "keyword").endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
ParsedDocument doc = mapper.parse(new SourceToParse("test", "1", BytesReference
@ -176,11 +176,11 @@ public class KeywordFieldMapperTests extends ESSingleNodeTestCase {
XContentType.JSON));
assertArrayEquals(new IndexableField[0], doc.rootDoc().getFields("field"));
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "keyword").field("null_value", "uri").endObject().endObject()
.endObject().endObject());
mapper = parser.parse("type", new CompressedXContent(mapping));
mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -206,11 +206,11 @@ public class KeywordFieldMapperTests extends ESSingleNodeTestCase {
}
public void testEnableStore() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "keyword").field("store", true).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -227,11 +227,11 @@ public class KeywordFieldMapperTests extends ESSingleNodeTestCase {
}
public void testDisableIndex() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "keyword").field("index", false).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -249,11 +249,11 @@ public class KeywordFieldMapperTests extends ESSingleNodeTestCase {
}
public void testDisableDocValues() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "keyword").field("doc_values", false).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -270,12 +270,12 @@ public class KeywordFieldMapperTests extends ESSingleNodeTestCase {
}
public void testIndexOptions() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "keyword")
.field("index_options", "freqs").endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -302,17 +302,17 @@ public class KeywordFieldMapperTests extends ESSingleNodeTestCase {
}
public void testBoost() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "keyword").field("boost", 2f).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
}
public void testEnableNorms() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", "keyword")
@ -322,7 +322,7 @@ public class KeywordFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
ParsedDocument doc = mapper.parse(new SourceToParse("test", "1", BytesReference
@ -341,12 +341,12 @@ public class KeywordFieldMapperTests extends ESSingleNodeTestCase {
}
public void testNormalizer() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field")
.field("type", "keyword").field("normalizer", "my_lowercase").endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());

4
server/src/test/java/org/elasticsearch/index/mapper/LegacyGeoShapeFieldMapperTests.java
View File

@ -53,7 +53,7 @@ public class LegacyGeoShapeFieldMapperTests extends ESSingleNodeTestCase {
}
public void testDefaultConfiguration() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type1")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("location")
.field("type", "geo_shape")
.field("strategy", "recursive")
@ -61,7 +61,7 @@ public class LegacyGeoShapeFieldMapperTests extends ESSingleNodeTestCase {
.endObject().endObject());
DocumentMapper defaultMapper = createIndex("test").mapperService().documentMapperParser()
.parse("type1", new CompressedXContent(mapping));
.parse("_doc", new CompressedXContent(mapping));
Mapper fieldMapper = defaultMapper.mappers().getMapper("location");
assertThat(fieldMapper, instanceOf(LegacyGeoShapeFieldMapper.class));
assertEquals(mapping, defaultMapper.mappingSource().toString());

2
server/src/test/java/org/elasticsearch/index/mapper/MultiFieldTests.java
View File

@ -186,7 +186,7 @@ public class MultiFieldTests extends ESSingleNodeTestCase {
XContentHelper.convertToMap(docMapper.mappingSource().compressedReference(), true, builder.contentType()).v2();
@SuppressWarnings("unchecked")
Map<String, Object> multiFields =
(Map<String, Object>) XContentMapValues.extractValue("type.properties.my_field.fields", sourceAsMap);
(Map<String, Object>) XContentMapValues.extractValue("_doc.properties.my_field.fields", sourceAsMap);
assertThat(multiFields.size(), equalTo(multiFieldNames.length));
int i = 0;

52
server/src/test/java/org/elasticsearch/index/mapper/NumberFieldMapperTests.java
View File

@ -53,11 +53,11 @@ public class NumberFieldMapperTests extends AbstractNumericFieldMapperTestCase {
@Override
public void doTestDefaults(String type) throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", type).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -81,11 +81,11 @@ public class NumberFieldMapperTests extends AbstractNumericFieldMapperTestCase {
@Override
public void doTestNotIndexed(String type) throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", type).field("index", false).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -104,11 +104,11 @@ public class NumberFieldMapperTests extends AbstractNumericFieldMapperTestCase {
@Override
public void doTestNoDocValues(String type) throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", type).field("doc_values", false).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -128,11 +128,11 @@ public class NumberFieldMapperTests extends AbstractNumericFieldMapperTestCase {
@Override
public void doTestStore(String type) throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", type).field("store", true).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -157,11 +157,11 @@ public class NumberFieldMapperTests extends AbstractNumericFieldMapperTestCase {
@Override
public void doTestCoerce(String type) throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", type).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -180,11 +180,11 @@ public class NumberFieldMapperTests extends AbstractNumericFieldMapperTestCase {
IndexableField dvField = fields[1];
assertEquals(DocValuesType.SORTED_NUMERIC, dvField.fieldType().docValuesType());
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", type).field("coerce", false).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper2 = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper2 = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper2.mappingSource().toString());
@ -200,11 +200,11 @@ public class NumberFieldMapperTests extends AbstractNumericFieldMapperTestCase {
@Override
protected void doTestDecimalCoerce(String type) throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", type).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -223,10 +223,10 @@ public class NumberFieldMapperTests extends AbstractNumericFieldMapperTestCase {
public void testIgnoreMalformed() throws Exception {
for (String type : TYPES) {
for (Object malformedValue : new Object[] { "a", Boolean.FALSE }) {
String mapping = Strings.toString(jsonBuilder().startObject().startObject("type").startObject("properties")
String mapping = Strings.toString(jsonBuilder().startObject().startObject("_doc").startObject("properties")
.startObject("field").field("type", type).endObject().endObject().endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -240,10 +240,10 @@ public class NumberFieldMapperTests extends AbstractNumericFieldMapperTestCase {
assertThat(e.getCause().getMessage(), containsString("not numeric, can not use numeric value accessors"));
}
mapping = Strings.toString(jsonBuilder().startObject().startObject("type").startObject("properties").startObject("field")
mapping = Strings.toString(jsonBuilder().startObject().startObject("_doc").startObject("properties").startObject("field")
.field("type", type).field("ignore_malformed", true).endObject().endObject().endObject().endObject());
DocumentMapper mapper2 = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper2 = parser.parse("_doc", new CompressedXContent(mapping));
ParsedDocument doc = mapper2.parse(new SourceToParse("test", "1",
BytesReference.bytes(jsonBuilder().startObject().field("field", malformedValue).endObject()), XContentType.JSON));
@ -268,9 +268,9 @@ public class NumberFieldMapperTests extends AbstractNumericFieldMapperTestCase {
};
for (Boolean ignoreMalformed : new Boolean[] { true, false }) {
String mapping = Strings.toString(
jsonBuilder().startObject().startObject("type").startObject("properties").startObject("field").field("type", type)
jsonBuilder().startObject().startObject("_doc").startObject("properties").startObject("field").field("type", type)
.field("ignore_malformed", ignoreMalformed).endObject().endObject().endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
MapperParsingException e = expectThrows(MapperParsingException.class,
@ -287,7 +287,7 @@ public class NumberFieldMapperTests extends AbstractNumericFieldMapperTestCase {
// not supported as of 5.0
for (String type : TYPES) {
DocumentMapperParser parser = createIndex("index-" + type).mapperService().documentMapperParser();
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties")
.startObject("foo")
.field("type", type)
@ -295,7 +295,7 @@ public class NumberFieldMapperTests extends AbstractNumericFieldMapperTestCase {
.endObject()
.endObject().endObject().endObject());
MapperParsingException e = expectThrows(MapperParsingException.class,
() -> parser.parse("type", new CompressedXContent(mapping)));
() -> parser.parse("_doc", new CompressedXContent(mapping)));
assertThat(e.getMessage(), containsString("Mapping definition for [foo] has unsupported parameters: [norms"));
}
}
@ -322,7 +322,7 @@ public class NumberFieldMapperTests extends AbstractNumericFieldMapperTestCase {
@Override
protected void doTestNullValue(String type) throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject()
.startObject("type")
.startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", type)
@ -330,7 +330,7 @@ public class NumberFieldMapperTests extends AbstractNumericFieldMapperTestCase {
.endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
ParsedDocument doc = mapper.parse(new SourceToParse("test", "1", BytesReference
@ -348,7 +348,7 @@ public class NumberFieldMapperTests extends AbstractNumericFieldMapperTestCase {
missing = 123L;
}
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject()
.startObject("type")
.startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", type)
@ -357,7 +357,7 @@ public class NumberFieldMapperTests extends AbstractNumericFieldMapperTestCase {
.endObject()
.endObject().endObject());
mapper = parser.parse("type", new CompressedXContent(mapping));
mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
doc = mapper.parse(new SourceToParse("test", "1", BytesReference

18
server/src/test/java/org/elasticsearch/index/mapper/ObjectMapperTests.java
View File

@ -181,24 +181,6 @@ public class ObjectMapperTests extends ESSingleNodeTestCase {
assertEquals(Dynamic.STRICT, mapper.root().dynamic());
}
public void testEmptyName() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder()
.startObject()
.startObject("")
.startObject("properties")
.startObject("name")
.field("type", "text")
.endObject()
.endObject()
.endObject().endObject());
// Empty name not allowed in index created after 5.0
IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> {
createIndex("test").mapperService().documentMapperParser().parse("", new CompressedXContent(mapping));
});
assertThat(e.getMessage(), containsString("name cannot be empty string"));
}
@Override
protected Collection<Class<? extends Plugin>> getPlugins() {
return pluginList(InternalSettingsPlugin.class);

36
server/src/test/java/org/elasticsearch/index/mapper/RangeFieldMapperTests.java
View File

@ -111,14 +111,14 @@ public class RangeFieldMapperTests extends AbstractNumericFieldMapperTestCase {
@Override
public void doTestDefaults(String type) throws Exception {
XContentBuilder mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
XContentBuilder mapping = XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", type);
if (type.equals("date_range")) {
mapping = mapping.field("format", DATE_FORMAT);
}
mapping = mapping.endObject().endObject().endObject().endObject();
DocumentMapper mapper = parser.parse("type", new CompressedXContent(Strings.toString(mapping)));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(Strings.toString(mapping)));
assertEquals(Strings.toString(mapping), mapper.mappingSource().toString());
ParsedDocument doc = mapper.parse(new SourceToParse("test", "1", BytesReference.bytes(XContentFactory.jsonBuilder()
@ -142,14 +142,14 @@ public class RangeFieldMapperTests extends AbstractNumericFieldMapperTestCase {
@Override
protected void doTestNotIndexed(String type) throws Exception {
XContentBuilder mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
XContentBuilder mapping = XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", type).field("index", false);
if (type.equals("date_range")) {
mapping = mapping.field("format", DATE_FORMAT);
}
mapping = mapping.endObject().endObject().endObject().endObject();
DocumentMapper mapper = parser.parse("type", new CompressedXContent(Strings.toString(mapping)));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(Strings.toString(mapping)));
assertEquals(Strings.toString(mapping), mapper.mappingSource().toString());
ParsedDocument doc = mapper.parse(new SourceToParse("test", "1", BytesReference.bytes(XContentFactory.jsonBuilder()
@ -167,13 +167,13 @@ public class RangeFieldMapperTests extends AbstractNumericFieldMapperTestCase {
@Override
protected void doTestNoDocValues(String type) throws Exception {
XContentBuilder mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
XContentBuilder mapping = XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", type).field("doc_values", false);
if (type.equals("date_range")) {
mapping = mapping.field("format", DATE_FORMAT);
}
mapping = mapping.endObject().endObject().endObject().endObject();
DocumentMapper mapper = parser.parse("type", new CompressedXContent(Strings.toString(mapping)));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(Strings.toString(mapping)));
assertEquals(Strings.toString(mapping), mapper.mappingSource().toString());
ParsedDocument doc = mapper.parse(new SourceToParse("test", "1", BytesReference.bytes(XContentFactory.jsonBuilder()
@ -193,13 +193,13 @@ public class RangeFieldMapperTests extends AbstractNumericFieldMapperTestCase {
@Override
protected void doTestStore(String type) throws Exception {
XContentBuilder mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
XContentBuilder mapping = XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", type).field("store", true);
if (type.equals("date_range")) {
mapping = mapping.field("format", DATE_FORMAT);
}
mapping = mapping.endObject().endObject().endObject().endObject();
DocumentMapper mapper = parser.parse("type", new CompressedXContent(Strings.toString(mapping)));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(Strings.toString(mapping)));
assertEquals(Strings.toString(mapping), mapper.mappingSource().toString());
ParsedDocument doc = mapper.parse(new SourceToParse("test", "1", BytesReference.bytes(XContentFactory.jsonBuilder()
@ -231,13 +231,13 @@ public class RangeFieldMapperTests extends AbstractNumericFieldMapperTestCase {
@Override
public void doTestCoerce(String type) throws IOException {
XContentBuilder mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
XContentBuilder mapping = XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", type);
if (type.equals("date_range")) {
mapping = mapping.field("format", DATE_FORMAT);
}
mapping = mapping.endObject().endObject().endObject().endObject();
DocumentMapper mapper = parser.parse("type", new CompressedXContent(Strings.toString(mapping)));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(Strings.toString(mapping)));
assertEquals(Strings.toString(mapping), mapper.mappingSource().toString());
@ -260,9 +260,9 @@ public class RangeFieldMapperTests extends AbstractNumericFieldMapperTestCase {
// date_range ignores the coerce parameter and epoch_millis date format truncates floats (see issue: #14641)
if (type.equals("date_range") == false) {
mapping = XContentFactory.jsonBuilder().startObject().startObject("type").startObject("properties").startObject("field")
mapping = XContentFactory.jsonBuilder().startObject().startObject("_doc").startObject("properties").startObject("field")
.field("type", type).field("coerce", false).endObject().endObject().endObject().endObject();
DocumentMapper mapper2 = parser.parse("type", new CompressedXContent(Strings.toString(mapping)));
DocumentMapper mapper2 = parser.parse("_doc", new CompressedXContent(Strings.toString(mapping)));
assertEquals(Strings.toString(mapping), mapper2.mappingSource().toString());
@ -279,11 +279,11 @@ public class RangeFieldMapperTests extends AbstractNumericFieldMapperTestCase {
@Override
protected void doTestDecimalCoerce(String type) throws IOException {
XContentBuilder mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
XContentBuilder mapping = XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", type);
mapping = mapping.endObject().endObject().endObject().endObject();
DocumentMapper mapper = parser.parse("type", new CompressedXContent(Strings.toString(mapping)));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(Strings.toString(mapping)));
assertEquals(Strings.toString(mapping), mapper.mappingSource().toString());
@ -313,14 +313,14 @@ public class RangeFieldMapperTests extends AbstractNumericFieldMapperTestCase {
@Override
protected void doTestNullValue(String type) throws IOException {
XContentBuilder mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
XContentBuilder mapping = XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", type).field("store", true);
if (type.equals("date_range")) {
mapping = mapping.field("format", DATE_FORMAT);
}
mapping = mapping.endObject().endObject().endObject().endObject();
DocumentMapper mapper = parser.parse("type", new CompressedXContent(Strings.toString(mapping)));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(Strings.toString(mapping)));
assertEquals(Strings.toString(mapping), mapper.mappingSource().toString());
// test null value for min and max
@ -383,14 +383,14 @@ public class RangeFieldMapperTests extends AbstractNumericFieldMapperTestCase {
}
public void doTestNoBounds(String type) throws IOException {
XContentBuilder mapping = XContentFactory.jsonBuilder().startObject().startObject("type")
XContentBuilder mapping = XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", type).field("store", true);
if (type.equals("date_range")) {
mapping = mapping.field("format", DATE_FORMAT);
}
mapping = mapping.endObject().endObject().endObject().endObject();
DocumentMapper mapper = parser.parse("type", new CompressedXContent(Strings.toString(mapping)));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(Strings.toString(mapping)));
assertEquals(Strings.toString(mapping), mapper.mappingSource().toString());
// test no bounds specified

48
server/src/test/java/org/elasticsearch/index/mapper/RootObjectMapperTests.java
View File

@ -32,99 +32,99 @@ public class RootObjectMapperTests extends ESSingleNodeTestCase {
public void testNumericDetection() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.startObject("_doc")
.field("numeric_detection", false)
.endObject()
.endObject());
MapperService mapperService = createIndex("test").mapperService();
DocumentMapper mapper = mapperService.merge("type", new CompressedXContent(mapping), MergeReason.MAPPING_UPDATE);
DocumentMapper mapper = mapperService.merge("_doc", new CompressedXContent(mapping), MergeReason.MAPPING_UPDATE);
assertEquals(mapping, mapper.mappingSource().toString());
// update with a different explicit value
String mapping2 = Strings.toString(XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.startObject("_doc")
.field("numeric_detection", true)
.endObject()
.endObject());
mapper = mapperService.merge("type", new CompressedXContent(mapping2), MergeReason.MAPPING_UPDATE);
mapper = mapperService.merge("_doc", new CompressedXContent(mapping2), MergeReason.MAPPING_UPDATE);
assertEquals(mapping2, mapper.mappingSource().toString());
// update with an implicit value: no change
String mapping3 = Strings.toString(XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.startObject("_doc")
.endObject()
.endObject());
mapper = mapperService.merge("type", new CompressedXContent(mapping3), MergeReason.MAPPING_UPDATE);
mapper = mapperService.merge("_doc", new CompressedXContent(mapping3), MergeReason.MAPPING_UPDATE);
assertEquals(mapping2, mapper.mappingSource().toString());
}
public void testDateDetection() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.startObject("_doc")
.field("date_detection", true)
.endObject()
.endObject());
MapperService mapperService = createIndex("test").mapperService();
DocumentMapper mapper = mapperService.merge("type", new CompressedXContent(mapping), MergeReason.MAPPING_UPDATE);
DocumentMapper mapper = mapperService.merge("_doc", new CompressedXContent(mapping), MergeReason.MAPPING_UPDATE);
assertEquals(mapping, mapper.mappingSource().toString());
// update with a different explicit value
String mapping2 = Strings.toString(XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.startObject("_doc")
.field("date_detection", false)
.endObject()
.endObject());
mapper = mapperService.merge("type", new CompressedXContent(mapping2), MergeReason.MAPPING_UPDATE);
mapper = mapperService.merge("_doc", new CompressedXContent(mapping2), MergeReason.MAPPING_UPDATE);
assertEquals(mapping2, mapper.mappingSource().toString());
// update with an implicit value: no change
String mapping3 = Strings.toString(XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.startObject("_doc")
.endObject()
.endObject());
mapper = mapperService.merge("type", new CompressedXContent(mapping3), MergeReason.MAPPING_UPDATE);
mapper = mapperService.merge("_doc", new CompressedXContent(mapping3), MergeReason.MAPPING_UPDATE);
assertEquals(mapping2, mapper.mappingSource().toString());
}
public void testDateFormatters() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.startObject("_doc")
.field("dynamic_date_formats", Arrays.asList("yyyy-MM-dd"))
.endObject()
.endObject());
MapperService mapperService = createIndex("test").mapperService();
DocumentMapper mapper = mapperService.merge("type", new CompressedXContent(mapping), MergeReason.MAPPING_UPDATE);
DocumentMapper mapper = mapperService.merge("_doc", new CompressedXContent(mapping), MergeReason.MAPPING_UPDATE);
assertEquals(mapping, mapper.mappingSource().toString());
// no update if formatters are not set explicitly
String mapping2 = Strings.toString(XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.startObject("_doc")
.endObject()
.endObject());
mapper = mapperService.merge("type", new CompressedXContent(mapping2), MergeReason.MAPPING_UPDATE);
mapper = mapperService.merge("_doc", new CompressedXContent(mapping2), MergeReason.MAPPING_UPDATE);
assertEquals(mapping, mapper.mappingSource().toString());
String mapping3 = Strings.toString(XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.startObject("_doc")
.field("dynamic_date_formats", Arrays.asList())
.endObject()
.endObject());
mapper = mapperService.merge("type", new CompressedXContent(mapping3), MergeReason.MAPPING_UPDATE);
mapper = mapperService.merge("_doc", new CompressedXContent(mapping3), MergeReason.MAPPING_UPDATE);
assertEquals(mapping3, mapper.mappingSource().toString());
}
public void testDynamicTemplates() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.startObject("_doc")
.startArray("dynamic_templates")
.startObject()
.startObject("my_template")
@ -138,25 +138,25 @@ public class RootObjectMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject());
MapperService mapperService = createIndex("test").mapperService();
DocumentMapper mapper = mapperService.merge("type", new CompressedXContent(mapping), MergeReason.MAPPING_UPDATE);
DocumentMapper mapper = mapperService.merge("_doc", new CompressedXContent(mapping), MergeReason.MAPPING_UPDATE);
assertEquals(mapping, mapper.mappingSource().toString());
// no update if templates are not set explicitly
String mapping2 = Strings.toString(XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.startObject("_doc")
.endObject()
.endObject());
mapper = mapperService.merge("type", new CompressedXContent(mapping2), MergeReason.MAPPING_UPDATE);
mapper = mapperService.merge("_doc", new CompressedXContent(mapping2), MergeReason.MAPPING_UPDATE);
assertEquals(mapping, mapper.mappingSource().toString());
String mapping3 = Strings.toString(XContentFactory.jsonBuilder()
.startObject()
.startObject("type")
.startObject("_doc")
.field("dynamic_templates", Arrays.asList())
.endObject()
.endObject());
mapper = mapperService.merge("type", new CompressedXContent(mapping3), MergeReason.MAPPING_UPDATE);
mapper = mapperService.merge("_doc", new CompressedXContent(mapping3), MergeReason.MAPPING_UPDATE);
assertEquals(mapping3, mapper.mappingSource().toString());
}

26
server/src/test/java/org/elasticsearch/index/mapper/SourceFieldMapperTests.java
View File

@ -121,13 +121,13 @@ public class SourceFieldMapperTests extends ESSingleNodeTestCase {
}
private void assertConflicts(String mapping1, String mapping2, DocumentMapperParser parser, String... conflicts) throws IOException {
DocumentMapper docMapper = parser.parse("type", new CompressedXContent(mapping1));
docMapper = parser.parse("type", docMapper.mappingSource());
DocumentMapper docMapper = parser.parse("_doc", new CompressedXContent(mapping1));
docMapper = parser.parse("_doc", docMapper.mappingSource());
if (conflicts.length == 0) {
docMapper.merge(parser.parse("type", new CompressedXContent(mapping2)).mapping());
docMapper.merge(parser.parse("_doc", new CompressedXContent(mapping2)).mapping());
} else {
try {
docMapper.merge(parser.parse("type", new CompressedXContent(mapping2)).mapping());
docMapper.merge(parser.parse("_doc", new CompressedXContent(mapping2)).mapping());
fail();
} catch (IllegalArgumentException e) {
for (String conflict : conflicts) {
@ -140,14 +140,14 @@ public class SourceFieldMapperTests extends ESSingleNodeTestCase {
public void testEnabledNotUpdateable() throws Exception {
DocumentMapperParser parser = createIndex("test").mapperService().documentMapperParser();
// using default of true
String mapping1 = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type").endObject().endObject());
String mapping2 = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping1 = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc").endObject().endObject());
String mapping2 = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("_source").field("enabled", false).endObject()
.endObject().endObject());
assertConflicts(mapping1, mapping2, parser, "Cannot update enabled setting for [_source]");
// not changing is ok
String mapping3 = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping3 = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("_source").field("enabled", true).endObject()
.endObject().endObject());
assertConflicts(mapping1, mapping3, parser);
@ -155,14 +155,14 @@ public class SourceFieldMapperTests extends ESSingleNodeTestCase {
public void testIncludesNotUpdateable() throws Exception {
DocumentMapperParser parser = createIndex("test").mapperService().documentMapperParser();
String defaultMapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type").endObject().endObject());
String mapping1 = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String defaultMapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc").endObject().endObject());
String mapping1 = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("_source").array("includes", "foo.*").endObject()
.endObject().endObject());
assertConflicts(defaultMapping, mapping1, parser, "Cannot update includes setting for [_source]");
assertConflicts(mapping1, defaultMapping, parser, "Cannot update includes setting for [_source]");
String mapping2 = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping2 = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("_source").array("includes", "foo.*", "bar.*").endObject()
.endObject().endObject());
assertConflicts(mapping1, mapping2, parser, "Cannot update includes setting for [_source]");
@ -173,14 +173,14 @@ public class SourceFieldMapperTests extends ESSingleNodeTestCase {
public void testExcludesNotUpdateable() throws Exception {
DocumentMapperParser parser = createIndex("test").mapperService().documentMapperParser();
String defaultMapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type").endObject().endObject());
String mapping1 = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String defaultMapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc").endObject().endObject());
String mapping1 = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("_source").array("excludes", "foo.*").endObject()
.endObject().endObject());
assertConflicts(defaultMapping, mapping1, parser, "Cannot update excludes setting for [_source]");
assertConflicts(mapping1, defaultMapping, parser, "Cannot update excludes setting for [_source]");
String mapping2 = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping2 = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("_source").array("excludes", "foo.*", "bar.*").endObject()
.endObject().endObject());
assertConflicts(mapping1, mapping2, parser, "Cannot update excludes setting for [_source]");

86
server/src/test/java/org/elasticsearch/index/mapper/TextFieldMapperTests.java
View File

@ -106,11 +106,11 @@ public class TextFieldMapperTests extends ESSingleNodeTestCase {
}
public void testDefaults() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "text").endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -138,11 +138,11 @@ public class TextFieldMapperTests extends ESSingleNodeTestCase {
}
public void testEnableStore() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "text").field("store", true).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -159,11 +159,11 @@ public class TextFieldMapperTests extends ESSingleNodeTestCase {
}
public void testDisableIndex() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "text").field("index", false).endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -179,14 +179,14 @@ public class TextFieldMapperTests extends ESSingleNodeTestCase {
}
public void testDisableNorms() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field")
.field("type", "text")
.field("norms", false)
.endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
@ -234,11 +234,11 @@ public class TextFieldMapperTests extends ESSingleNodeTestCase {
}
public void testDefaultPositionIncrementGap() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field").field("type", "text").endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = indexService.mapperService().merge("type",
DocumentMapper mapper = indexService.mapperService().merge("_doc",
new CompressedXContent(mapping), MergeReason.MAPPING_UPDATE);
assertEquals(mapping, mapper.mappingSource().toString());
@ -273,14 +273,14 @@ public class TextFieldMapperTests extends ESSingleNodeTestCase {
public void testPositionIncrementGap() throws IOException {
final int positionIncrementGap = randomIntBetween(1, 1000);
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field")
.field("type", "text")
.field("position_increment_gap", positionIncrementGap)
.endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = indexService.mapperService().merge("type",
DocumentMapper mapper = indexService.mapperService().merge("_doc",
new CompressedXContent(mapping), MergeReason.MAPPING_UPDATE);
assertEquals(mapping, mapper.mappingSource().toString());
@ -314,7 +314,7 @@ public class TextFieldMapperTests extends ESSingleNodeTestCase {
}
public void testSearchAnalyzerSerialization() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", "text")
@ -323,11 +323,11 @@ public class TextFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject().endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
// special case: default index analyzer
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", "text")
@ -336,10 +336,10 @@ public class TextFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject().endObject().endObject());
mapper = parser.parse("type", new CompressedXContent(mapping));
mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", "text")
@ -347,11 +347,11 @@ public class TextFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject().endObject().endObject());
mapper = parser.parse("type", new CompressedXContent(mapping));
mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
// special case: default search analyzer
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", "text")
@ -360,17 +360,17 @@ public class TextFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject().endObject().endObject());
mapper = parser.parse("type", new CompressedXContent(mapping));
mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", "text")
.field("analyzer", "keyword")
.endObject()
.endObject().endObject().endObject());
mapper = parser.parse("type", new CompressedXContent(mapping));
mapper = parser.parse("_doc", new CompressedXContent(mapping));
XContentBuilder builder = XContentFactory.jsonBuilder();
builder.startObject();
@ -384,7 +384,7 @@ public class TextFieldMapperTests extends ESSingleNodeTestCase {
}
public void testSearchQuoteAnalyzerSerialization() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", "text")
@ -394,11 +394,11 @@ public class TextFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject().endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
// special case: default index/search analyzer
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", "text")
@ -408,7 +408,7 @@ public class TextFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject().endObject().endObject());
mapper = parser.parse("type", new CompressedXContent(mapping));
mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
}
@ -488,14 +488,14 @@ public class TextFieldMapperTests extends ESSingleNodeTestCase {
}
public void testEagerGlobalOrdinals() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field")
.field("type", "text")
.field("eager_global_ordinals", true)
.endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
FieldMapper fieldMapper = (FieldMapper) mapper.mappers().getMapper("field");
@ -503,13 +503,13 @@ public class TextFieldMapperTests extends ESSingleNodeTestCase {
}
public void testFielddata() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field")
.field("type", "text")
.endObject().endObject()
.endObject().endObject());
DocumentMapper disabledMapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper disabledMapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, disabledMapper.mappingSource().toString());
IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> {
FieldMapper fieldMapper = (FieldMapper) disabledMapper.mappers().getMapper("field");
@ -517,14 +517,14 @@ public class TextFieldMapperTests extends ESSingleNodeTestCase {
});
assertThat(e.getMessage(), containsString("Fielddata is disabled"));
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field")
.field("type", "text")
.field("fielddata", true)
.endObject().endObject()
.endObject().endObject());
DocumentMapper enabledMapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper enabledMapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, enabledMapper.mappingSource().toString());
@ -544,7 +544,7 @@ public class TextFieldMapperTests extends ESSingleNodeTestCase {
}
public void testFrequencyFilter() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field")
.field("type", "text")
.field("fielddata", true)
@ -555,7 +555,7 @@ public class TextFieldMapperTests extends ESSingleNodeTestCase {
.endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
TextFieldMapper fieldMapper = (TextFieldMapper) mapper.mappers().getMapper("field");
@ -778,7 +778,7 @@ public class TextFieldMapperTests extends ESSingleNodeTestCase {
throw new UnsupportedOperationException();
}, null);
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", "text")
@ -793,10 +793,10 @@ public class TextFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
queryShardContext.getMapperService().merge("type", new CompressedXContent(mapping), MergeReason.MAPPING_UPDATE);
queryShardContext.getMapperService().merge("_doc", new CompressedXContent(mapping), MergeReason.MAPPING_UPDATE);
Query q = new MatchPhraseQueryBuilder("field", "two words").toQuery(queryShardContext);
assertThat(q, is(new PhraseQuery("field._index_phrase", "two words")));
@ -862,7 +862,7 @@ public class TextFieldMapperTests extends ESSingleNodeTestCase {
}
{
String badConfigMapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String badConfigMapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field")
.field("type", "text")
.field("index", "false")
@ -870,13 +870,13 @@ public class TextFieldMapperTests extends ESSingleNodeTestCase {
.endObject().endObject()
.endObject().endObject());
IllegalArgumentException e = expectThrows(IllegalArgumentException.class,
() -> parser.parse("type", new CompressedXContent(badConfigMapping))
() -> parser.parse("_doc", new CompressedXContent(badConfigMapping))
);
assertThat(e.getMessage(), containsString("Cannot set index_phrases on unindexed field [field]"));
}
{
String badConfigMapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String badConfigMapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field")
.field("type", "text")
.field("index_options", "freqs")
@ -884,7 +884,7 @@ public class TextFieldMapperTests extends ESSingleNodeTestCase {
.endObject().endObject()
.endObject().endObject());
IllegalArgumentException e = expectThrows(IllegalArgumentException.class,
() -> parser.parse("type", new CompressedXContent(badConfigMapping))
() -> parser.parse("_doc", new CompressedXContent(badConfigMapping))
);
assertThat(e.getMessage(), containsString("Cannot set index_phrases on field [field] if positions are not enabled"));
}
@ -893,7 +893,7 @@ public class TextFieldMapperTests extends ESSingleNodeTestCase {
public void testIndexPrefixMapping() throws IOException {
{
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("type")
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject().startObject("_doc")
.startObject("properties").startObject("field")
.field("type", "text")
.field("analyzer", "standard")
@ -904,7 +904,7 @@ public class TextFieldMapperTests extends ESSingleNodeTestCase {
.endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
assertThat(mapper.mappers().getMapper("field._index_prefix").toString(), containsString("prefixChars=2:10"));

2
server/src/test/java/org/elasticsearch/index/mapper/TypeFieldMapperTests.java
View File

@ -75,7 +75,7 @@ public class TypeFieldMapperTests extends ESSingleNodeTestCase {
assertTrue(values.advanceExact(0));
assertEquals(0, values.nextOrd());
assertEquals(SortedSetDocValues.NO_MORE_ORDS, values.nextOrd());
assertEquals(new BytesRef("type"), values.lookupOrd(0));
assertEquals(new BytesRef("_doc"), values.lookupOrd(0));
r.close();
dir.close();
}

52
x-pack/plugin/mapper-flattened/src/test/java/org/elasticsearch/xpack/flattened/mapper/FlatObjectFieldMapperTests.java
View File

@ -56,7 +56,7 @@ public class FlatObjectFieldMapperTests extends ESSingleNodeTestCase {
public void testDefaults() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject()
.startObject("type")
.startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", "flattened")
@ -65,7 +65,7 @@ public class FlatObjectFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
BytesReference doc = BytesReference.bytes(XContentFactory.jsonBuilder().startObject()
@ -111,7 +111,7 @@ public class FlatObjectFieldMapperTests extends ESSingleNodeTestCase {
public void testDisableIndex() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject()
.startObject("type")
.startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", "flattened")
@ -121,7 +121,7 @@ public class FlatObjectFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
BytesReference doc = BytesReference.bytes(XContentFactory.jsonBuilder().startObject()
@ -143,7 +143,7 @@ public class FlatObjectFieldMapperTests extends ESSingleNodeTestCase {
public void testDisableDocValues() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject()
.startObject("type")
.startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", "flattened")
@ -153,7 +153,7 @@ public class FlatObjectFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
BytesReference doc = BytesReference.bytes(XContentFactory.jsonBuilder().startObject()
@ -195,7 +195,7 @@ public class FlatObjectFieldMapperTests extends ESSingleNodeTestCase {
public void testIndexOptions() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject()
.startObject("type")
.startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", "flattened")
@ -205,12 +205,12 @@ public class FlatObjectFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
for (String indexOptions : Arrays.asList("positions", "offsets")) {
String invalidMapping = Strings.toString(XContentFactory.jsonBuilder().startObject()
.startObject("type")
.startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", "flattened")
@ -220,14 +220,14 @@ public class FlatObjectFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject());
IllegalArgumentException e = expectThrows(IllegalArgumentException.class,
() -> parser.parse("type", new CompressedXContent(invalidMapping)));
() -> parser.parse("_doc", new CompressedXContent(invalidMapping)));
assertEquals("The [flattened] field does not support positions, got [index_options]=" + indexOptions, e.getMessage());
}
}
public void testNullField() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject()
.startObject("type")
.startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", "flattened")
@ -236,7 +236,7 @@ public class FlatObjectFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
BytesReference doc = BytesReference.bytes(XContentFactory.jsonBuilder().startObject()
@ -250,7 +250,7 @@ public class FlatObjectFieldMapperTests extends ESSingleNodeTestCase {
public void testMalformedJson() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject()
.startObject("type")
.startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", "flattened")
@ -259,7 +259,7 @@ public class FlatObjectFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
BytesReference doc1 = BytesReference.bytes(XContentFactory.jsonBuilder().startObject()
@ -276,7 +276,7 @@ public class FlatObjectFieldMapperTests extends ESSingleNodeTestCase {
public void testFieldMultiplicity() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject()
.startObject("type")
.startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", "flattened")
@ -285,7 +285,7 @@ public class FlatObjectFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
BytesReference doc = BytesReference.bytes(XContentFactory.jsonBuilder().startObject()
@ -318,7 +318,7 @@ public class FlatObjectFieldMapperTests extends ESSingleNodeTestCase {
public void testDepthLimit() throws IOException {
// First verify the default behavior when depth_limit is not set.
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject()
.startObject("type")
.startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", "flattened")
@ -327,7 +327,7 @@ public class FlatObjectFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
BytesReference doc = BytesReference.bytes(XContentFactory.jsonBuilder().startObject()
@ -344,7 +344,7 @@ public class FlatObjectFieldMapperTests extends ESSingleNodeTestCase {
// Set a lower value for depth_limit and check that the field is rejected.
String newMapping = Strings.toString(XContentFactory.jsonBuilder().startObject()
.startObject("type")
.startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", "flattened")
@ -355,7 +355,7 @@ public class FlatObjectFieldMapperTests extends ESSingleNodeTestCase {
.endObject());
DocumentMapper newMapper = mapper.merge(
parser.parse("type", new CompressedXContent(newMapping)).mapping());
parser.parse("_doc", new CompressedXContent(newMapping)).mapping());
expectThrows(MapperParsingException.class, () ->
newMapper.parse(new SourceToParse("test", "1", doc, XContentType.JSON)));
@ -363,7 +363,7 @@ public class FlatObjectFieldMapperTests extends ESSingleNodeTestCase {
public void testEagerGlobalOrdinals() throws IOException {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject()
.startObject("type")
.startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", "flattened")
@ -371,7 +371,7 @@ public class FlatObjectFieldMapperTests extends ESSingleNodeTestCase {
.endObject().endObject()
.endObject().endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
FieldMapper fieldMapper = (FieldMapper) mapper.mappers().getMapper("field");
@ -381,7 +381,7 @@ public class FlatObjectFieldMapperTests extends ESSingleNodeTestCase {
public void testIgnoreAbove() throws IOException {
// First verify the default behavior when ignore_above is not set.
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject()
.startObject("type")
.startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", "flattened")
@ -390,7 +390,7 @@ public class FlatObjectFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
BytesReference doc = BytesReference.bytes(XContentFactory.jsonBuilder().startObject()
@ -427,7 +427,7 @@ public class FlatObjectFieldMapperTests extends ESSingleNodeTestCase {
public void testNullValues() throws Exception {
String mapping = Strings.toString(XContentFactory.jsonBuilder().startObject()
.startObject("type")
.startObject("_doc")
.startObject("properties")
.startObject("field")
.field("type", "flattened")
@ -440,7 +440,7 @@ public class FlatObjectFieldMapperTests extends ESSingleNodeTestCase {
.endObject()
.endObject());
DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));
DocumentMapper mapper = parser.parse("_doc", new CompressedXContent(mapping));
assertEquals(mapping, mapper.mappingSource().toString());
BytesReference doc = BytesReference.bytes(XContentFactory.jsonBuilder().startObject()