clean up tests

jdconrad · Mar 18, 2024 · 51a3e98 · 51a3e98
1 parent 18c3c3a
commit 51a3e98
Show file tree

Hide file tree

Showing 4 changed files with 69 additions and 12 deletions.
diff --git a/server/src/main/java/org/elasticsearch/index/mapper/BooleanFieldMapper.java b/server/src/main/java/org/elasticsearch/index/mapper/BooleanFieldMapper.java
@@ -318,8 +318,11 @@ public Query termsQuery(Collection<?> values, SearchExecutionContext context) {
             if (isIndexed()) {
                 return super.termsQuery(values, context);
             } else {
-                BooleanQuery.Builder builder = new BooleanQuery.Builder();
                 Set<?> dedupe = new HashSet<>(values);
+                if (dedupe.size() == 1) {
+                    return new ConstantScoreQuery(termQuery(dedupe.iterator().next(), context));
+                }
+                BooleanQuery.Builder builder = new BooleanQuery.Builder();
                 for (Object value : dedupe) {
                     builder.add(termQuery(value, context), BooleanClause.Occur.SHOULD);
                 }

diff --git a/server/src/main/java/org/elasticsearch/index/mapper/MappedFieldType.java b/server/src/main/java/org/elasticsearch/index/mapper/MappedFieldType.java
@@ -235,8 +235,11 @@ public Query termQueryCaseInsensitive(Object value, @Nullable SearchExecutionCon
      * {@link ConstantScoreQuery} around a {@link BooleanQuery} whose {@link Occur#SHOULD} clauses
      * are generated with {@link #termQuery}. */
     public Query termsQuery(Collection<?> values, @Nullable SearchExecutionContext context) {
-        BooleanQuery.Builder builder = new BooleanQuery.Builder();
         Set<?> dedupe = new HashSet<>(values);
+        if (dedupe.size() == 1) {
+            return new ConstantScoreQuery(termQuery(dedupe.iterator().next(), context));
+        }
+        BooleanQuery.Builder builder = new BooleanQuery.Builder();
         for (Object value : dedupe) {
             builder.add(termQuery(value, context), Occur.SHOULD);
         }

diff --git a/server/src/main/java/org/elasticsearch/index/mapper/MapperRegistry.java b/server/src/main/java/org/elasticsearch/index/mapper/MapperRegistry.java
@@ -23,7 +23,7 @@
  */
 public final class MapperRegistry {
 
-    public final Map<String, Mapper.TypeParser> mapperParsers;
+    private final Map<String, Mapper.TypeParser> mapperParsers;
     private final Map<String, RuntimeField.Parser> runtimeFieldParsers;
     private final Map<String, MetadataFieldMapper.TypeParser> metadataMapperParsers;
     private final Map<String, MetadataFieldMapper.TypeParser> metadataMapperParsers7x;
@@ -37,7 +37,7 @@ public MapperRegistry(
         Map<String, MetadataFieldMapper.TypeParser> metadataMapperParsers,
         Function<String, Predicate<String>> fieldFilter
     ) {
-        this.mapperParsers = new LinkedHashMap<>(mapperParsers);
+        this.mapperParsers = Collections.unmodifiableMap(new LinkedHashMap<>(mapperParsers));
         this.runtimeFieldParsers = runtimeFieldParsers;
         this.metadataMapperParsers = Collections.unmodifiableMap(new LinkedHashMap<>(metadataMapperParsers));
         Map<String, MetadataFieldMapper.TypeParser> metadata7x = new LinkedHashMap<>(metadataMapperParsers);

diff --git a/...lugin/wildcard/src/test/java/org/elasticsearch/xpack/wildcard/mapper/TermsQueryTests.java b/...lugin/wildcard/src/test/java/org/elasticsearch/xpack/wildcard/mapper/TermsQueryTests.java
@@ -7,29 +7,34 @@
 
 package org.elasticsearch.xpack.wildcard.mapper;
 
+import org.apache.lucene.search.ConstantScoreQuery;
 import org.apache.lucene.search.Query;
 import org.elasticsearch.common.compress.CompressedXContent;
 import org.elasticsearch.index.mapper.MapperService;
+import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.QueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
+import org.elasticsearch.plugins.Plugin;
 import org.elasticsearch.test.AbstractBuilderTestCase;
+import org.elasticsearch.xpack.wildcard.Wildcard;
 
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
 
 public class TermsQueryTests extends AbstractBuilderTestCase {
 
-    public void testDuplicateTerms() throws IOException {
-        String[] duplicates = new String[1023];
-        Arrays.fill(duplicates, "duplicate");
-        TermsQueryBuilder termsQueryBuilder = new TermsQueryBuilder("mapped_wildcard", duplicates);
-        termsQueryBuilder.rewrite(createQueryRewriteContext());
-        Query query = termsQueryBuilder.toQuery(createSearchExecutionContext());
-        query.toString();
+    protected Collection<Class<? extends Plugin>> getPlugins() {
+        return List.of(Wildcard.class);
     }
 
     @Override
     protected void initializeAdditionalMappings(MapperService mapperService) throws IOException {
-        mapperService.getMapperRegistry().mapperParsers.put("wildcard", WildcardFieldMapper.PARSER);
         mapperService.merge("_doc", new CompressedXContent(org.elasticsearch.common.Strings.format("""
             {
               "properties": {
@@ -39,4 +44,50 @@ protected void initializeAdditionalMappings(MapperService mapperService) throws
               }
             }""")), MapperService.MergeReason.MAPPING_UPDATE);
     }
+
+    public void testSingleDuplicateTerms() throws IOException {
+        String[] duplicates = new String[1023];
+        Arrays.fill(duplicates, "duplicate");
+        QueryBuilder termsQueryBuilder = new TermsQueryBuilder("mapped_wildcard", duplicates);
+        termsQueryBuilder = termsQueryBuilder.rewrite(createQueryRewriteContext());
+        Query actual = termsQueryBuilder.toQuery(createSearchExecutionContext());
+
+        QueryBuilder wildcardQueryBuilder = new WildcardQueryBuilder("mapped_wildcard", "duplicate");
+        wildcardQueryBuilder = wildcardQueryBuilder.rewrite(createQueryRewriteContext());
+        Query expected = new ConstantScoreQuery(wildcardQueryBuilder.toQuery(createSearchExecutionContext()));
+
+        assertEquals(expected, actual);
+    }
+
+    public void testMultiDuplicateTerms() throws IOException {
+        int numTerms = randomIntBetween(2, 10);
+        List<String> randomTerms = new ArrayList<>(numTerms);
+        for (int i = 0; i < numTerms; ++i) {
+            randomTerms.add(randomAlphaOfLengthBetween(1, 1024));
+        }
+        int totalTerms = randomIntBetween(numTerms * 5, 1023);
+        String[] duplicates = new String[totalTerms];
+        for (int i = 0; i < numTerms; ++i) {
+            duplicates[i] = randomTerms.get(i);
+        }
+        for (int i = numTerms; i < totalTerms; ++i) {
+            duplicates[i] = randomTerms.get(randomIntBetween(0, numTerms - 1));
+        }
+
+        QueryBuilder termsQueryBuilder = new TermsQueryBuilder("mapped_wildcard", duplicates);
+        termsQueryBuilder = termsQueryBuilder.rewrite(createQueryRewriteContext());
+        Query actual = termsQueryBuilder.toQuery(createSearchExecutionContext());
+
+        Set<String> ordered = new HashSet<>(randomTerms);
+        BoolQueryBuilder boolQueryBuilder = new BoolQueryBuilder();
+        for (String randomTerm : ordered) {
+            QueryBuilder wildcardQueryBuilder = new WildcardQueryBuilder("mapped_wildcard", randomTerm);
+            wildcardQueryBuilder = wildcardQueryBuilder.rewrite(createQueryRewriteContext());
+            boolQueryBuilder.should(wildcardQueryBuilder);
+        }
+        QueryBuilder expectedQueryBuilder = boolQueryBuilder.rewrite(createQueryRewriteContext());
+        Query expected = new ConstantScoreQuery(expectedQueryBuilder.toQuery(createSearchExecutionContext()));
+
+        assertEquals(expected, actual);
+    }
 }