Randomizing and extending toQuery test setup

Author: cbuescher

src/main/java/org/elasticsearch/index/query/ExistsQueryBuilder.java

@@ -54,7 +54,7 @@ public ExistsQueryBuilder(String name) {
     }
 
     /**
-     * @return the field name has to exists for this query to match
+     * @return the field name that has to exists for this query to match
      */
     public String name() {
         return this.name;
@@ -113,7 +113,7 @@ public static Query newFilter(QueryParseContext parseContext, String fieldPatter
             if (fieldNamesMapper!= null && fieldNamesMapper.enabled()) {
                 final String f;
                 if (mapper != null) {
-                    f = mapper.names().indexName();
+                    f = mapper.fieldType().names().indexName();
                 } else {
                     f = field;
                 }

src/test/java/org/elasticsearch/index/query/BaseQueryTestCase.java

@@ -44,7 +44,11 @@
 import org.elasticsearch.index.IndexNameModule;
 import org.elasticsearch.index.analysis.AnalysisModule;
 import org.elasticsearch.index.cache.IndexCacheModule;
+import org.elasticsearch.index.mapper.ContentPath;
+import org.elasticsearch.index.mapper.Mapper.BuilderContext;
 import org.elasticsearch.index.mapper.MapperService;
+import org.elasticsearch.index.mapper.MapperUtils;
+import org.elasticsearch.index.mapper.internal.FieldNamesFieldMapper;
 import org.elasticsearch.index.query.functionscore.FunctionScoreModule;
 import org.elasticsearch.index.settings.IndexSettingsModule;
 import org.elasticsearch.index.similarity.SimilarityModule;
@@ -78,6 +82,8 @@ public abstract class BaseQueryTestCase<QB extends QueryBuilder<QB>> extends Ela
     protected static final String STRING_FIELD_NAME = "text";
     protected static final String DOUBLE_FIELD_NAME = "double";
     protected static final String BOOLEAN_FIELD_NAME = "boolean";
+    protected static final String[] mappedFieldNames = new String[]{DATE_FIELD_NAME, INT_FIELD_NAME,
+        STRING_FIELD_NAME, DOUBLE_FIELD_NAME, BOOLEAN_FIELD_NAME};
 
     private static Injector injector;
     private static IndexQueryParserService queryParserService;
@@ -137,6 +143,14 @@ protected void configure() {
                     STRING_FIELD_NAME, "type=string").string()), false);
             currentTypes[i] = type;
         }
+
+        // randomly disable FieldNamesFieldMapper (enabled by default) to be able to test bwc cases
+        FieldNamesFieldMapper fieldNamesMapper = (FieldNamesFieldMapper) mapperService.fullName(FieldNamesFieldMapper.NAME);
+        if (fieldNamesMapper != null) {
+            boolean randomEnabled = randomBoolean();
+            FieldNamesFieldMapper alternativeFieldMapper = new FieldNamesFieldMapper.Builder().enabled(randomEnabled).build(new BuilderContext(settings, new ContentPath(1)));
+            MapperUtils.merge(fieldNamesMapper, alternativeFieldMapper);
+        }
     }
 
     @AfterClass
@@ -266,7 +280,10 @@ public void testSerialization() throws IOException {
      * @return a new {@link QueryParseContext} based on the base test index and queryParserService
      */
     protected static QueryParseContext createContext() {
-        return new QueryParseContext(index, queryParserService);
+        QueryParseContext context = new QueryParseContext(index, queryParserService);
+        QueryParseContext.setTypes(currentTypes);
+        return context;
+
     }
 
     protected static void assertQueryHeader(XContentParser parser, String expectedParserName) throws IOException {

src/test/java/org/elasticsearch/index/query/ExistsQueryBuilderTest.java

@@ -19,11 +19,18 @@
 
 package org.elasticsearch.index.query;
 
+import org.apache.lucene.search.BooleanClause;
+import org.apache.lucene.search.BooleanQuery;
 import org.apache.lucene.search.ConstantScoreQuery;
 import org.apache.lucene.search.Query;
+import org.apache.lucene.search.TermRangeQuery;
 import org.elasticsearch.cluster.metadata.MetaData;
+import org.elasticsearch.common.lucene.search.Queries;
+import org.elasticsearch.index.mapper.FieldMapper;
+import org.elasticsearch.index.mapper.internal.FieldNamesFieldMapper;
 
 import java.io.IOException;
+import java.util.Collection;
 
 import static org.hamcrest.Matchers.equalTo;
 
@@ -36,7 +43,27 @@ protected ExistsQueryBuilder createEmptyQueryBuilder() {
 
     @Override
     protected Query createExpectedQuery(ExistsQueryBuilder queryBuilder, QueryParseContext context) throws IOException {
-        return ExistsQueryBuilder.newFilter(context, queryBuilder.name(), queryBuilder.queryName());
+        final FieldNamesFieldMapper fieldNamesMapper = (FieldNamesFieldMapper)context.mapperService().fullName(FieldNamesFieldMapper.NAME);
+        Collection<String> fields = context.simpleMatchToIndexNames(queryBuilder.name());
+
+        if (fields.isEmpty()) {
+            return Queries.newMatchNoDocsQuery();
+        }
+
+        BooleanQuery boolFilter = new BooleanQuery();
+        for (String field : fields) {
+            if (fieldNamesMapper == null || !fieldNamesMapper.enabled()) {
+                FieldMapper mapper = context.fieldMapper(field);
+                if (mapper == null) {
+                    boolFilter.add(new TermRangeQuery(field, null, null, true, true), BooleanClause.Occur.SHOULD);
+                } else {
+                    boolFilter.add(mapper.rangeQuery(null, null, true, true, context), BooleanClause.Occur.SHOULD);
+                }
+            } else {
+                boolFilter.add(fieldNamesMapper.termQuery(field, context), BooleanClause.Occur.SHOULD);
+            }
+        }
+        return new ConstantScoreQuery(boolFilter);
     }
 
     @Override
@@ -46,25 +73,31 @@ protected void assertLuceneQuery(ExistsQueryBuilder queryBuilder, Query query, Q
             if (query instanceof ConstantScoreQuery) {
                 // get the inner filter which is the one stored unter query_name
                 query = ((ConstantScoreQuery) query).getQuery();
+                assertThat(namedQuery, equalTo(query));
+            } else {
+                assertNull(namedQuery);
             }
-            assertThat(namedQuery, equalTo(query));
         }
     }
 
     @Override
     protected ExistsQueryBuilder createTestQueryBuilder() {
-        ExistsQueryBuilder query;
+        String fieldPattern;
         if (frequently()) {
-            // simple field pattern
-            query = new ExistsQueryBuilder(randomAsciiOfLengthBetween(1, 10));
+            fieldPattern = mappedFieldNames[randomIntBetween(0, mappedFieldNames.length - 1)];
         } else {
-            // All or wildcard pattern
+            fieldPattern = randomAsciiOfLengthBetween(1, 10);
+        }
+        // also sometimes test wildcard patterns
+        if (randomBoolean()) {
             if (randomBoolean()) {
-                query = new ExistsQueryBuilder(MetaData.ALL);
+                fieldPattern = fieldPattern+"*";
             } else {
-                query = new ExistsQueryBuilder(randomAsciiOfLengthBetween(1, 3) + "*");
+                fieldPattern = MetaData.ALL;
             }
         }
+        ExistsQueryBuilder query = new ExistsQueryBuilder(fieldPattern);
+
         if (randomBoolean()) {
             query.queryName(randomAsciiOfLengthBetween(1, 10));
         }