public void testPercolatorFieldMapper_noQuery() throws Exception {
    addQueryMapping();
    ParsedDocument doc =
        mapperService
            .documentMapper(typeName)
            .parse(
                "test",
                typeName,
                "1",
                XContentFactory.jsonBuilder().startObject().endObject().bytes());
    assertThat(doc.rootDoc().getFields(fieldType.getQueryBuilderFieldName()).length, equalTo(0));

    try {
      mapperService
          .documentMapper(typeName)
          .parse(
              "test",
              typeName,
              "1",
              XContentFactory.jsonBuilder().startObject().nullField(fieldName).endObject().bytes());
    } catch (MapperParsingException e) {
      assertThat(
          e.getDetailedMessage(), containsString("query malformed, must start with start_object"));
    }
  }
  @Test
  public void testNumericDetectionDefault() throws Exception {
    String mapping =
        XContentFactory.jsonBuilder()
            .startObject()
            .startObject("type")
            .endObject()
            .endObject()
            .string();

    DocumentMapper defaultMapper = MapperTestUtils.newParser().parse(mapping);

    ParsedDocument doc =
        defaultMapper.parse(
            "type",
            "1",
            XContentFactory.jsonBuilder()
                .startObject()
                .field("s_long", "100")
                .field("s_double", "100.0")
                .endObject()
                .bytes());

    FieldMapper mapper = defaultMapper.mappers().smartNameFieldMapper("s_long");
    assertThat(mapper, instanceOf(StringFieldMapper.class));

    mapper = defaultMapper.mappers().smartNameFieldMapper("s_double");
    assertThat(mapper, instanceOf(StringFieldMapper.class));
  }
  @Test
  public void testEnabled() throws Exception {
    String mapping =
        XContentFactory.jsonBuilder()
            .startObject()
            .startObject("type")
            .startObject("_timestamp")
            .field("enabled", "yes")
            .field("store", "yes")
            .endObject()
            .endObject()
            .endObject()
            .string();
    DocumentMapper docMapper = MapperTests.newParser().parse(mapping);
    byte[] source =
        XContentFactory.jsonBuilder()
            .startObject()
            .field("field", "value")
            .endObject()
            .copiedBytes();
    ParsedDocument doc =
        docMapper.parse(SourceToParse.source(source).type("type").id("1").timestamp(1));

    assertThat(doc.rootDoc().getFieldable("_timestamp").isStored(), equalTo(true));
    assertThat(doc.rootDoc().getFieldable("_timestamp").isIndexed(), equalTo(true));
    assertThat(doc.rootDoc().getFieldable("_timestamp").tokenStreamValue(), notNullValue());
  }
 @Test
 public void test_all_disabled_after_default_enabled() throws Exception {
   XContentBuilder mapping =
       XContentFactory.jsonBuilder()
           .startObject()
           .startObject("properties")
           .startObject("some_text")
           .field("type", "string")
           .endObject()
           .endObject()
           .endObject();
   XContentBuilder mappingUpdate =
       XContentFactory.jsonBuilder()
           .startObject()
           .startObject("_all")
           .field("enabled", false)
           .endObject()
           .startObject("properties")
           .startObject("text")
           .field("type", "string")
           .endObject()
           .endObject()
           .endObject();
   testConflictWhileMergingAndMappingUnchanged(mapping, mappingUpdate);
 }
  @Override
  public void login(final RestRequest request, final ActionListener<String[]> listener) {
    String username = request.param(usernameKey);
    String password = request.param(passwordKey);
    final BytesReference content = request.content();
    final XContentType xContentType = XContentFactory.xContentType(content);
    XContentParser parser = null;
    try {
      parser = XContentFactory.xContent(xContentType).createParser(content);
      final XContentParser.Token t = parser.nextToken();
      if (t != null) {
        final Map<String, Object> contentMap = parser.map();
        username = MapUtil.getAsString(contentMap, usernameKey, username);
        password = MapUtil.getAsString(contentMap, passwordKey, password);
      }
    } catch (final Exception e) {
      listener.onFailure(e);
      return;
    } finally {
      if (parser != null) {
        parser.close();
      }
    }

    if (username == null) {
      listener.onResponse(new String[0]);
      return;
    }

    processLogin(username, password, listener);
  }
  @Test
  public void testLatLonInOneValueStored() throws Exception {
    String mapping =
        XContentFactory.jsonBuilder()
            .startObject()
            .startObject("type")
            .startObject("properties")
            .startObject("point")
            .field("type", "geo_point")
            .field("lat_lon", true)
            .field("store", "yes")
            .endObject()
            .endObject()
            .endObject()
            .endObject()
            .string();

    DocumentMapper defaultMapper = MapperTestUtils.newParser().parse(mapping);

    ParsedDocument doc =
        defaultMapper.parse(
            "type",
            "1",
            XContentFactory.jsonBuilder()
                .startObject()
                .field("point", "1.2,1.3")
                .endObject()
                .bytes());

    assertThat(doc.rootDoc().getField("point.lat"), notNullValue());
    assertThat(doc.rootDoc().getField("point.lat").numericValue().doubleValue(), equalTo(1.2));
    assertThat(doc.rootDoc().getField("point.lon"), notNullValue());
    assertThat(doc.rootDoc().getField("point.lon").numericValue().doubleValue(), equalTo(1.3));
    assertThat(doc.rootDoc().get("point"), equalTo("1.2,1.3"));
  }
  public void testConflictNewType() throws Exception {
    XContentBuilder mapping =
        XContentFactory.jsonBuilder()
            .startObject()
            .startObject("type1")
            .startObject("properties")
            .startObject("foo")
            .field("type", "long")
            .endObject()
            .endObject()
            .endObject()
            .endObject();
    MapperService mapperService =
        createIndex("test", Settings.settingsBuilder().build(), "type1", mapping).mapperService();

    XContentBuilder update =
        XContentFactory.jsonBuilder()
            .startObject()
            .startObject("type2")
            .startObject("properties")
            .startObject("foo")
            .field("type", "double")
            .endObject()
            .endObject()
            .endObject()
            .endObject();

    try {
      mapperService.merge(
          "type2",
          new CompressedXContent(update.string()),
          MapperService.MergeReason.MAPPING_UPDATE,
          false);
      fail();
    } catch (IllegalArgumentException e) {
      // expected
      assertTrue(
          e.getMessage(),
          e.getMessage().contains("mapper [foo] cannot be changed from type [long] to [double]"));
    }

    try {
      mapperService.merge(
          "type2",
          new CompressedXContent(update.string()),
          MapperService.MergeReason.MAPPING_UPDATE,
          false);
      fail();
    } catch (IllegalArgumentException e) {
      // expected
      assertTrue(
          e.getMessage(),
          e.getMessage().contains("mapper [foo] cannot be changed from type [long] to [double]"));
    }

    assertTrue(
        mapperService.documentMapper("type1").mapping().root().getMapper("foo")
            instanceof LongFieldMapper);
    assertNull(mapperService.documentMapper("type2"));
  }
  public void testNotIndexed() throws Exception {
    String mapping =
        XContentFactory.jsonBuilder()
            .startObject()
            .startObject("type")
            .startObject("properties")
            .startObject("field")
            .field("type", "ip")
            .field("index", false)
            .endObject()
            .endObject()
            .endObject()
            .endObject()
            .string();

    DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));

    assertEquals(mapping, mapper.mappingSource().toString());

    ParsedDocument doc =
        mapper.parse(
            "test",
            "type",
            "1",
            XContentFactory.jsonBuilder().startObject().field("field", "::1").endObject().bytes());

    IndexableField[] fields = doc.rootDoc().getFields("field");
    assertEquals(1, fields.length);
    IndexableField dvField = fields[0];
    assertEquals(DocValuesType.SORTED_SET, dvField.fieldType().docValuesType());
  }
  public void testNoDocValues() throws Exception {
    String mapping =
        XContentFactory.jsonBuilder()
            .startObject()
            .startObject("type")
            .startObject("properties")
            .startObject("field")
            .field("type", "ip")
            .field("doc_values", false)
            .endObject()
            .endObject()
            .endObject()
            .endObject()
            .string();

    DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));

    assertEquals(mapping, mapper.mappingSource().toString());

    ParsedDocument doc =
        mapper.parse(
            "test",
            "type",
            "1",
            XContentFactory.jsonBuilder().startObject().field("field", "::1").endObject().bytes());

    IndexableField[] fields = doc.rootDoc().getFields("field");
    assertEquals(1, fields.length);
    IndexableField pointField = fields[0];
    assertEquals(1, pointField.fieldType().pointDimensionCount());
    assertEquals(
        new BytesRef(InetAddressPoint.encode(InetAddresses.forString("::1"))),
        pointField.binaryValue());
  }
 public void testJoinFieldNotSet() throws Exception {
   String mapping =
       XContentFactory.jsonBuilder()
           .startObject()
           .startObject("type")
           .endObject()
           .endObject()
           .string();
   DocumentMapper docMapper =
       createIndex("test")
           .mapperService()
           .documentMapperParser()
           .parse("type", new CompressedXContent(mapping));
   ParsedDocument doc =
       docMapper.parse(
           SourceToParse.source(
               "test",
               "type",
               "1",
               XContentFactory.jsonBuilder()
                   .startObject()
                   .field("x_field", "x_value")
                   .endObject()
                   .bytes()));
   assertEquals(0, getNumberOfFieldWithParentPrefix(doc.rootDoc()));
 }
  @Override
  public XContentBuilder newBuilder(@Nullable BytesReference autoDetectSource, boolean useFiltering)
      throws IOException {
    XContentType contentType = XContentType.fromMediaTypeOrFormat(format);
    if (contentType == null) {
      // try and guess it from the auto detect source
      if (autoDetectSource != null) {
        contentType = XContentFactory.xContentType(autoDetectSource);
      }
    }
    if (contentType == null) {
      // default to JSON
      contentType = XContentType.JSON;
    }

    Set<String> includes = Collections.emptySet();
    Set<String> excludes = Collections.emptySet();
    if (useFiltering) {
      Set<String> filters = Strings.splitStringByCommaToSet(filterPath);
      includes = filters.stream().filter(INCLUDE_FILTER).collect(toSet());
      excludes = filters.stream().filter(EXCLUDE_FILTER).map(f -> f.substring(1)).collect(toSet());
    }

    XContentBuilder builder =
        new XContentBuilder(
            XContentFactory.xContent(contentType), bytesOutput(), includes, excludes);
    if (pretty) {
      builder.prettyPrint().lfAtEnd();
    }

    builder.humanReadable(human);
    return builder;
  }
  @Override
  public void doTestNoDocValues(String type) throws Exception {
    String mapping =
        XContentFactory.jsonBuilder()
            .startObject()
            .startObject("type")
            .startObject("properties")
            .startObject("field")
            .field("type", type)
            .field("doc_values", false)
            .endObject()
            .endObject()
            .endObject()
            .endObject()
            .string();

    DocumentMapper mapper = parser.parse("type", new CompressedXContent(mapping));

    assertEquals(mapping, mapper.mappingSource().toString());

    ParsedDocument doc =
        mapper.parse(
            "test",
            "type",
            "1",
            XContentFactory.jsonBuilder().startObject().field("field", 123).endObject().bytes());

    IndexableField[] fields = doc.rootDoc().getFields("field");
    assertEquals(1, fields.length);
    IndexableField pointField = fields[0];
    assertEquals(1, pointField.fieldType().pointDimensionCount());
    assertEquals(123, pointField.numericValue().doubleValue(), 0d);
  }
Exemple #13
0
  @Test
  public void testDynamicFalse() throws IOException {
    String mapping =
        XContentFactory.jsonBuilder()
            .startObject()
            .startObject("type")
            .field("dynamic", "false")
            .startObject("properties")
            .startObject("field1")
            .field("type", "string")
            .endObject()
            .endObject()
            .endObject()
            .endObject()
            .string();

    DocumentMapper defaultMapper = MapperTestUtils.newParser().parse(mapping);

    ParsedDocument doc =
        defaultMapper.parse(
            "type",
            "1",
            XContentFactory.jsonBuilder()
                .startObject()
                .field("field1", "value1")
                .field("field2", "value2")
                .bytes());

    assertThat(doc.rootDoc().get("field1"), equalTo("value1"));
    assertThat(doc.rootDoc().get("field2"), nullValue());
  }
Exemple #14
0
  @Test
  public void testDynamicStrict() throws IOException {
    String mapping =
        XContentFactory.jsonBuilder()
            .startObject()
            .startObject("type")
            .field("dynamic", "strict")
            .startObject("properties")
            .startObject("field1")
            .field("type", "string")
            .endObject()
            .endObject()
            .endObject()
            .endObject()
            .string();

    DocumentMapper defaultMapper = MapperTestUtils.newParser().parse(mapping);

    try {
      defaultMapper.parse(
          "type",
          "1",
          XContentFactory.jsonBuilder()
              .startObject()
              .field("field1", "value1")
              .field("field2", "value2")
              .bytes());
      assert false;
    } catch (StrictDynamicMappingException e) {
      // all is well
    }
  }
  public void testInjectIntoDocDuringParsing() throws Exception {
    String mapping =
        XContentFactory.jsonBuilder()
            .startObject()
            .startObject("type")
            .endObject()
            .endObject()
            .string();
    DocumentMapper defaultMapper =
        createIndex("test").mapperService().documentMapperParser().parse(mapping);

    ParsedDocument doc =
        defaultMapper.parse(
            "type",
            "1",
            XContentFactory.jsonBuilder()
                .startObject()
                .field("a", "100")
                .startObject("b")
                .field("c", 42)
                .endObject()
                .endObject()
                .bytes());

    assertFieldNames(set("a", "b", "b.c", "_uid", "_type", "_version", "_source", "_all"), doc);
  }
  public void testSerializeDefaults() throws Exception {
    String mapping =
        XContentFactory.jsonBuilder()
            .startObject()
            .startObject("type")
            .startObject("properties")
            .startObject("field")
            .field("type", "ip")
            .endObject()
            .endObject()
            .endObject()
            .endObject()
            .string();

    DocumentMapper docMapper = parser.parse("type", new CompressedXContent(mapping));
    IpFieldMapper mapper = (IpFieldMapper) docMapper.root().getMapper("field");
    XContentBuilder builder = XContentFactory.jsonBuilder().startObject();
    mapper.doXContentBody(builder, true, ToXContent.EMPTY_PARAMS);
    String got = builder.endObject().string();

    // it would be nice to check the entire serialized default mapper, but there are
    // a whole lot of bogus settings right now it picks up from calling super.doXContentBody...
    assertTrue(got, got.contains("\"null_value\":null"));
    assertTrue(got, got.contains("\"ignore_malformed\":false"));
    assertTrue(got, got.contains("\"include_in_all\":false"));
  }
  public void testExplicitEnabled() throws Exception {
    String mapping =
        XContentFactory.jsonBuilder()
            .startObject()
            .startObject("type")
            .startObject("_field_names")
            .field("enabled", true)
            .endObject()
            .endObject()
            .endObject()
            .string();
    DocumentMapper docMapper =
        createIndex("test").mapperService().documentMapperParser().parse(mapping);
    FieldNamesFieldMapper fieldNamesMapper = docMapper.rootMapper(FieldNamesFieldMapper.class);
    assertTrue(fieldNamesMapper.enabled());

    ParsedDocument doc =
        docMapper.parse(
            "type",
            "1",
            XContentFactory.jsonBuilder()
                .startObject()
                .field("field", "value")
                .endObject()
                .bytes());

    assertFieldNames(set("field", "_uid", "_type", "_version", "_source", "_all"), doc);
  }
  public void testNestedList() throws IOException {
    XContentBuilder builder =
        XContentFactory.jsonBuilder()
            .startObject()
            .startArray("some_array")
            .startArray()
            .endArray()
            .startArray()
            .value(1)
            .value(3)
            .endArray()
            .startArray()
            .value(2)
            .endArray()
            .endArray()
            .endObject();

    try (XContentParser parser =
        XContentFactory.xContent(XContentType.JSON).createParser(builder.string())) {
      assertEquals(XContentParser.Token.START_OBJECT, parser.nextToken());
      assertEquals(XContentParser.Token.FIELD_NAME, parser.nextToken());
      assertEquals("some_array", parser.currentName());
      if (random().nextBoolean()) {
        // sometimes read the start array token, sometimes not
        assertEquals(XContentParser.Token.START_ARRAY, parser.nextToken());
      }
      assertEquals(
          Arrays.asList(Collections.<Integer>emptyList(), Arrays.asList(1, 3), Arrays.asList(2)),
          parser.list());
    }
  }
  @Test
  public void testGeoHashValue() throws Exception {
    String mapping =
        XContentFactory.jsonBuilder()
            .startObject()
            .startObject("type")
            .startObject("properties")
            .startObject("point")
            .field("type", "geo_point")
            .field("lat_lon", true)
            .endObject()
            .endObject()
            .endObject()
            .endObject()
            .string();

    DocumentMapper defaultMapper = MapperTestUtils.newParser().parse(mapping);

    ParsedDocument doc =
        defaultMapper.parse(
            "type",
            "1",
            XContentFactory.jsonBuilder()
                .startObject()
                .field("point", GeoHashUtils.encode(1.2, 1.3))
                .endObject()
                .bytes());

    assertThat(doc.rootDoc().getField("point.lat"), notNullValue());
    assertThat(doc.rootDoc().getField("point.lon"), notNullValue());
    assertThat(doc.rootDoc().get("point"), notNullValue());
  }
  public void testNestedMapInList() throws IOException {
    XContentBuilder builder =
        XContentFactory.jsonBuilder()
            .startObject()
            .startArray("some_array")
            .startObject()
            .field("foo", "bar")
            .endObject()
            .startObject()
            .endObject()
            .endArray()
            .endObject();

    try (XContentParser parser =
        XContentFactory.xContent(XContentType.JSON).createParser(builder.string())) {
      assertEquals(XContentParser.Token.START_OBJECT, parser.nextToken());
      assertEquals(XContentParser.Token.FIELD_NAME, parser.nextToken());
      assertEquals("some_array", parser.currentName());
      if (random().nextBoolean()) {
        // sometimes read the start array token, sometimes not
        assertEquals(XContentParser.Token.START_ARRAY, parser.nextToken());
      }
      assertEquals(Arrays.asList(singletonMap("foo", "bar"), emptyMap()), parser.list());
    }
  }
 public void testConflictFieldsMapping(String fieldName) throws Exception {
   // test store, ... all the parameters that are not to be changed just like in other fields
   XContentBuilder mapping =
       XContentFactory.jsonBuilder()
           .startObject()
           .startObject("type")
           .startObject(fieldName)
           .field("enabled", true)
           .field("store", "no")
           .endObject()
           .endObject()
           .endObject();
   XContentBuilder mappingUpdate =
       XContentFactory.jsonBuilder()
           .startObject()
           .startObject("type")
           .startObject(fieldName)
           .field("enabled", true)
           .field("store", "yes")
           .endObject()
           .startObject("properties")
           .startObject("text")
           .field("type", "string")
           .endObject()
           .endObject()
           .endObject()
           .endObject();
   testConflictWhileMergingAndMappingUnchanged(mapping, mappingUpdate);
 }
  /** test exception on missing `end` and `match` parameter in parser */
  public void testParseEnd() throws IOException {
    {
      XContentBuilder builder = XContentFactory.jsonBuilder();
      builder.startObject();
      builder.startObject(SpanFirstQueryBuilder.NAME);
      builder.field("match");
      spanTermQuery("description", "jumped").toXContent(builder, null);
      builder.endObject();
      builder.endObject();

      ParsingException e = expectThrows(ParsingException.class, () -> parseQuery(builder.string()));
      assertTrue(e.getMessage().contains("spanFirst must have [end] set"));
    }
    {
      XContentBuilder builder = XContentFactory.jsonBuilder();
      builder.startObject();
      builder.startObject(SpanFirstQueryBuilder.NAME);
      builder.field("end", 10);
      builder.endObject();
      builder.endObject();

      ParsingException e = expectThrows(ParsingException.class, () -> parseQuery(builder.string()));
      assertTrue(e.getMessage().contains("spanFirst must have [match] span query clause"));
    }
  }
Exemple #23
0
  @Test
  public void testUpsert() throws Exception {
    createIndex();
    ClusterHealthResponse clusterHealth =
        client.admin().cluster().prepareHealth().setWaitForGreenStatus().execute().actionGet();
    assertThat(clusterHealth.timedOut(), equalTo(false));
    assertThat(clusterHealth.status(), equalTo(ClusterHealthStatus.GREEN));

    client
        .prepareUpdate("test", "type1", "1")
        .setUpsert(XContentFactory.jsonBuilder().startObject().field("field", 1).endObject())
        .setScript("ctx._source.field += 1")
        .execute()
        .actionGet();

    for (int i = 0; i < 5; i++) {
      GetResponse getResponse = client.prepareGet("test", "type1", "1").execute().actionGet();
      assertThat(getResponse.sourceAsMap().get("field").toString(), equalTo("1"));
    }

    client
        .prepareUpdate("test", "type1", "1")
        .setUpsert(XContentFactory.jsonBuilder().startObject().field("field", 1).endObject())
        .setScript("ctx._source.field += 1")
        .execute()
        .actionGet();

    for (int i = 0; i < 5; i++) {
      GetResponse getResponse = client.prepareGet("test", "type1", "1").execute().actionGet();
      assertThat(getResponse.sourceAsMap().get("field").toString(), equalTo("2"));
    }
  }
  public void testDisabled() throws Exception {
    String mapping =
        XContentFactory.jsonBuilder()
            .startObject()
            .startObject("type")
            .startObject("_field_names")
            .field("enabled", false)
            .endObject()
            .endObject()
            .endObject()
            .string();
    DocumentMapper docMapper =
        createIndex("test").mapperService().documentMapperParser().parse(mapping);
    FieldNamesFieldMapper fieldNamesMapper = docMapper.rootMapper(FieldNamesFieldMapper.class);
    assertFalse(fieldNamesMapper.enabled());

    ParsedDocument doc =
        docMapper.parse(
            "type",
            "1",
            XContentFactory.jsonBuilder()
                .startObject()
                .field("field", "value")
                .endObject()
                .bytes());

    assertNull(doc.rootDoc().get("_field_names"));
  }
  public void testIncludeInObjectNotAllowed() throws Exception {
    String mapping =
        XContentFactory.jsonBuilder()
            .startObject()
            .startObject("type")
            .endObject()
            .endObject()
            .string();
    DocumentMapper docMapper =
        createIndex("test").mapperService().documentMapperParser().parse(mapping);

    try {
      docMapper.parse(
          "test",
          "type",
          "1",
          XContentFactory.jsonBuilder().startObject().field("_all", "foo").endObject().bytes());
      fail("Expected failure to parse metadata field");
    } catch (MapperParsingException e) {
      assertTrue(
          e.getMessage(),
          e.getMessage()
              .contains("Field [_all] is a metadata field and cannot be added inside a document"));
    }
  }
  public void testDisablingBackcompat() throws Exception {
    // before 1.5, disabling happened by setting index:no
    String mapping =
        XContentFactory.jsonBuilder()
            .startObject()
            .startObject("type")
            .startObject("_field_names")
            .field("index", "no")
            .endObject()
            .endObject()
            .endObject()
            .string();

    Settings indexSettings =
        ImmutableSettings.builder()
            .put(IndexMetaData.SETTING_VERSION_CREATED, Version.V_1_4_2.id)
            .build();
    DocumentMapper docMapper =
        createIndex("test", indexSettings).mapperService().documentMapperParser().parse(mapping);
    FieldNamesFieldMapper fieldNamesMapper = docMapper.rootMapper(FieldNamesFieldMapper.class);
    assertFalse(fieldNamesMapper.enabled());

    ParsedDocument doc =
        docMapper.parse(
            "type",
            "1",
            XContentFactory.jsonBuilder()
                .startObject()
                .field("field", "value")
                .endObject()
                .bytes());

    assertNull(doc.rootDoc().get("_field_names"));
  }
  @Test
  public void testLatLonInOneValue() throws Exception {
    String mapping =
        XContentFactory.contentTextBuilder(XContentType.JSON)
            .startObject()
            .startObject("type")
            .startObject("properties")
            .startObject("point")
            .field("type", "geo_point")
            .field("geohash", true)
            .field("lat_lon", false)
            .endObject()
            .endObject()
            .endObject()
            .endObject()
            .string();

    XContentDocumentMapper defaultMapper = XContentMapperTests.newParser().parse(mapping);

    ParsedDocument doc =
        defaultMapper.parse(
            "type",
            "1",
            XContentFactory.jsonBuilder()
                .startObject()
                .field("point", "1.2,1.3")
                .endObject()
                .copiedBytes());

    MatcherAssert.assertThat(doc.doc().getField("point.lat"), nullValue());
    MatcherAssert.assertThat(doc.doc().getField("point.lon"), nullValue());
    MatcherAssert.assertThat(
        doc.doc().get("point.geohash"), equalTo(GeoHashUtils.encode(1.2, 1.3)));
  }
  public void testMergingMappings() throws Exception {
    String enabledMapping =
        XContentFactory.jsonBuilder()
            .startObject()
            .startObject("type")
            .startObject("_field_names")
            .field("enabled", true)
            .endObject()
            .endObject()
            .endObject()
            .string();
    String disabledMapping =
        XContentFactory.jsonBuilder()
            .startObject()
            .startObject("type")
            .startObject("_field_names")
            .field("enabled", false)
            .endObject()
            .endObject()
            .endObject()
            .string();
    DocumentMapperParser parser = createIndex("test").mapperService().documentMapperParser();

    DocumentMapper mapperEnabled = parser.parse(enabledMapping);
    DocumentMapper mapperDisabled = parser.parse(disabledMapping);
    mapperEnabled.merge(mapperDisabled, DocumentMapper.MergeFlags.mergeFlags().simulate(false));
    assertFalse(mapperEnabled.rootMapper(FieldNamesFieldMapper.class).enabled());

    mapperEnabled = parser.parse(enabledMapping);
    mapperDisabled.merge(mapperEnabled, DocumentMapper.MergeFlags.mergeFlags().simulate(false));
    assertTrue(mapperEnabled.rootMapper(FieldNamesFieldMapper.class).enabled());
  }
  @Test
  public void testThatDisablingWorksWhenMerging() throws Exception {
    String enabledMapping =
        XContentFactory.jsonBuilder()
            .startObject()
            .startObject("type")
            .startObject("_size")
            .field("enabled", true)
            .endObject()
            .endObject()
            .endObject()
            .string();
    DocumentMapper enabledMapper = MapperTests.newParser().parse(enabledMapping);

    String disabledMapping =
        XContentFactory.jsonBuilder()
            .startObject()
            .startObject("type")
            .startObject("_size")
            .field("enabled", false)
            .endObject()
            .endObject()
            .endObject()
            .string();
    DocumentMapper disabledMapper = MapperTests.newParser().parse(disabledMapping);

    enabledMapper.merge(disabledMapper, DocumentMapper.MergeFlags.mergeFlags().simulate(false));
    assertThat(enabledMapper.SizeFieldMapper().enabled(), is(false));
  }
  public void testCompressEnabled() throws Exception {
    String mapping =
        XContentFactory.jsonBuilder()
            .startObject()
            .startObject("type")
            .startObject("_source")
            .field("compress", true)
            .endObject()
            .endObject()
            .endObject()
            .string();

    DocumentMapper documentMapper =
        createIndex("test", settings).mapperService().documentMapperParser().parse(mapping);

    ParsedDocument doc =
        documentMapper.parse(
            "test",
            "type",
            "1",
            XContentFactory.jsonBuilder()
                .startObject()
                .field("field1", "value1")
                .field("field2", "value2")
                .endObject()
                .bytes());

    BytesRef bytes = doc.rootDoc().getBinaryValue("_source");
    assertThat(CompressorFactory.isCompressed(new BytesArray(bytes)), equalTo(true));
  }