Package org.elasticsearch.index.mapper

Class MapperTestCase

java.lang.Object
org.junit.Assert
org.apache.lucene.tests.util.LuceneTestCase
org.elasticsearch.test.ESTestCase
org.elasticsearch.index.mapper.MapperServiceTestCase
org.elasticsearch.index.mapper.MapperTestCase
public abstract class MapperTestCase extends MapperServiceTestCase
Base class for testing Mappers.

  • Constructor Details

    • MapperTestCase

      public MapperTestCase()

  • Method Details

    • minimalMapping

      protected abstract void minimalMapping(org.elasticsearch.xcontent.XContentBuilder b) throws IOException
      Throws:
      IOException

    • writeField

      protected void writeField(org.elasticsearch.xcontent.XContentBuilder builder) throws IOException
      Writes the field and a sample value for it to the provided XContentBuilder. To be overridden in case the field should not be written at all in documents, like in the case of runtime fields.
      Throws:
      IOException

    • getSampleValueForDocument

      protected abstract Object getSampleValueForDocument()
      Returns a sample value for the field, to be used in a document

    • getSampleValueForQuery

      protected Object getSampleValueForQuery()
      Returns a sample value for the field, to be used when querying the field. Normally this is the same format as what is indexed as part of a document, and returned by getSampleValueForDocument(), but there are cases where fields are queried differently frow how they are indexed e.g. token_count or runtime fields

    • testExistsQueryMinimalMapping

      public final void testExistsQueryMinimalMapping() throws IOException
      This test verifies that the exists query created is the appropriate one, and aligns with the data structures being created for a document with a value for the field. This can only be verified for the minimal mapping. Field types that allow configurable doc_values or norms should write their own tests that creates the different mappings combinations and invoke assertExistsQuery(MapperService) to verify the behaviour.
      Throws:
      IOException

    • assertExistsQuery

      protected void assertExistsQuery(org.elasticsearch.index.mapper.MapperService mapperService) throws IOException
      Throws:
      IOException

    • assertExistsQuery

      protected void assertExistsQuery(org.elasticsearch.index.mapper.MappedFieldType fieldType, org.apache.lucene.search.Query query, org.elasticsearch.index.mapper.LuceneDocument fields)

    • assertNoFieldNamesField

      protected static void assertNoFieldNamesField(org.elasticsearch.index.mapper.LuceneDocument fields)

    • assertHasNorms

      protected static void assertHasNorms(org.elasticsearch.index.mapper.LuceneDocument doc, String field)

    • assertDocValuesField

      protected static void assertDocValuesField(org.elasticsearch.index.mapper.LuceneDocument doc, String field)

    • assertNoDocValuesField

      protected static void assertNoDocValuesField(org.elasticsearch.index.mapper.LuceneDocument doc, String field)

    • assertDimension

      protected <T> void assertDimension(boolean isDimension, Function<T,Boolean> checker) throws IOException
      Throws:
      IOException

    • assertMetricType

      protected <T> void assertMetricType(String metricType, Function<T,Enum<org.elasticsearch.index.mapper.TimeSeriesParams.MetricType>> checker) throws IOException
      Throws:
      IOException

    • testEmptyName

      public final void testEmptyName()

    • testMinimalSerializesToItself

      public final void testMinimalSerializesToItself() throws IOException
      Throws:
      IOException

    • testMinimalToMaximal

      public void testMinimalToMaximal() throws IOException
      Throws:
      IOException

    • assertParseMinimalWarnings

      protected final void assertParseMinimalWarnings()

    • assertParseMaximalWarnings

      protected final void assertParseMaximalWarnings()

    • getParseMinimalWarnings

      protected String[] getParseMinimalWarnings()

    • getParseMaximalWarnings

      protected String[] getParseMaximalWarnings()

    • supportsMeta

      protected boolean supportsMeta()
      Override to disable testing meta in fields that don't support it.

    • metaMapping

      protected void metaMapping(org.elasticsearch.xcontent.XContentBuilder b) throws IOException
      Throws:
      IOException

    • testMeta

      public final void testMeta() throws IOException
      Throws:
      IOException

    • testDeprecatedBoost

      public final void testDeprecatedBoost() throws IOException
      Throws:
      IOException

    • fetchFromDocValues

      protected final List<?> fetchFromDocValues(org.elasticsearch.index.mapper.MapperService mapperService, org.elasticsearch.index.mapper.MappedFieldType ft, org.elasticsearch.search.DocValueFormat format, Object sourceValue) throws IOException
      Use a ValueFetcher to extract values from doc values.
      Throws:
      IOException

    • registerParameters

      protected abstract void registerParameters(MapperTestCase.ParameterChecker checker) throws IOException
      Throws:
      IOException

    • testUpdates

      public void testUpdates() throws IOException
      Throws:
      IOException

    • testTextSearchInfoConsistency

      public final void testTextSearchInfoConsistency() throws IOException
      Throws:
      IOException

    • assertSearchable

      protected void assertSearchable(org.elasticsearch.index.mapper.MappedFieldType fieldType)

    • testFetch

      public final void testFetch() throws IOException
      Asserts that fetching a single value from doc values and from the native MappedFieldType.valueFetcher(org.elasticsearch.index.query.SearchExecutionContext, java.lang.String) produce the same results.

      Generally this method covers many many random cases but rarely. So if it fails its generally a good idea to capture its randomized parameters into a new method so we can be sure we consistently test any unique and interesting failure case. See the tests for DateFieldMapper for some examples.

      Throws:
      IOException

    • testFetchMany

      public final void testFetchMany() throws IOException
      Asserts that fetching many values from doc values and from the native MappedFieldType.valueFetcher(org.elasticsearch.index.query.SearchExecutionContext, java.lang.String) produce the same results.

      Generally this method covers many many random cases but rarely. So if it fails its generally a good idea to capture its randomized parameters into a new method so we can be sure we consistently test any unique and interesting failure case. See the tests for DateFieldMapper for some examples.

      Throws:
      IOException

    • randomFetchTestMapper

      protected final org.elasticsearch.index.mapper.MapperService randomFetchTestMapper() throws IOException
      Throws:
      IOException

    • randomFetchTestFieldConfig

      protected void randomFetchTestFieldConfig(org.elasticsearch.xcontent.XContentBuilder b) throws IOException
      Field configuration for testFetch() and testFetchMany(). Default implementation delegates to minimalMapping(org.elasticsearch.xcontent.XContentBuilder) but can be overridden to randomize the field type and options.
      Throws:
      IOException

    • randomFetchTestFormat

      protected String randomFetchTestFormat()
      A random format to use when tripping in testFetch() and testFetchMany().

    • registerDimensionChecks

      protected void registerDimensionChecks(MapperTestCase.ParameterChecker checker) throws IOException
      Test that dimension parameter is not updateable
      Throws:
      IOException

    • generateRandomInputValue

      protected abstract Object generateRandomInputValue(org.elasticsearch.index.mapper.MappedFieldType ft)
      Create a random _source value for this field. Must be compatible with XContentBuilder.value(Object) and the field's parser.

    • assertFetch

      protected void assertFetch(org.elasticsearch.index.mapper.MapperService mapperService, String field, Object value, String format) throws IOException
      Assert that fetching a value using MappedFieldType.valueFetcher(org.elasticsearch.index.query.SearchExecutionContext, java.lang.String) produces the same value as fetching using doc values.
      Throws:
      IOException

    • dedupAfterFetch

      protected boolean dedupAfterFetch()
      A few field types (e.g. keyword fields) don't allow duplicate values, so in those cases we need to de-dup our expected values. Field types where this is the case should overwrite this. The default is to not de-duplicate though.

    • supportsSearchLookup

      protected boolean supportsSearchLookup()
      Returns:
      whether or not this field type supports access to its values from a SearchLookup

    • testIndexTimeFieldData

      public final void testIndexTimeFieldData() throws IOException
      Checks that field data from this field produces the same values for query-time scripts and for index-time scripts
      Throws:
      IOException

    • supportsStoredFields

      protected boolean supportsStoredFields()

    • minimalStoreMapping

      protected void minimalStoreMapping(org.elasticsearch.xcontent.XContentBuilder b) throws IOException
      Throws:
      IOException

    • testIndexTimeStoredFieldsAccess

      public final void testIndexTimeStoredFieldsAccess() throws IOException
      Checks that loading stored fields for this field produces the same set of values for query time scripts and index time scripts
      Throws:
      IOException

    • testNullInput

      public final void testNullInput() throws Exception
      Throws:
      Exception

    • allowsNullValues

      protected boolean allowsNullValues()

    • testMinimalIsInvalidInRoutingPath

      public final void testMinimalIsInvalidInRoutingPath() throws IOException
      Throws:
      IOException

    • minimalIsInvalidRoutingPathErrorMessage

      protected String minimalIsInvalidRoutingPathErrorMessage(org.elasticsearch.index.mapper.Mapper mapper)