Add unit tests for ReverseNestedAggregator

core/src/test/java/org/elasticsearch/search/aggregations/AggregatorTestCase.java

@@ -34,13 +34,20 @@
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.util.MockBigArrays;
 import org.elasticsearch.index.IndexSettings;
+import org.elasticsearch.index.cache.bitset.BitsetFilterCache;
+import org.elasticsearch.index.cache.bitset.BitsetFilterCache.Listener;
 import org.elasticsearch.index.cache.query.DisabledQueryCache;
 import org.elasticsearch.index.engine.Engine;
 import org.elasticsearch.index.fielddata.IndexFieldDataCache;
 import org.elasticsearch.index.fielddata.IndexFieldDataService;
+import org.elasticsearch.index.mapper.ContentPath;
 import org.elasticsearch.index.mapper.MappedFieldType;
+import org.elasticsearch.index.mapper.Mapper.BuilderContext;
 import org.elasticsearch.index.mapper.MapperService;
+import org.elasticsearch.index.mapper.ObjectMapper;
+import org.elasticsearch.index.mapper.ObjectMapper.Nested;
 import org.elasticsearch.index.query.QueryShardContext;
+import org.elasticsearch.index.query.support.NestedScope;
 import org.elasticsearch.indices.breaker.CircuitBreakerService;
 import org.elasticsearch.indices.breaker.NoneCircuitBreakerService;
 import org.elasticsearch.indices.fielddata.cache.IndicesFieldDataCache;
@@ -59,6 +66,7 @@
 import java.util.List;
 
 import static org.mockito.Matchers.anyObject;
+import static org.mockito.Matchers.anyString;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
@@ -69,6 +77,7 @@
  * {@link AggregationBuilder} instance.
  */
 public abstract class AggregatorTestCase extends ESTestCase {
+    private static final String NESTEDFIELD_PREFIX = "nested_";
     private List<Releasable> releasables = new ArrayList<>();
 
     protected <A extends Aggregator, B extends AggregationBuilder> A createAggregator(B aggregationBuilder,
@@ -119,6 +128,15 @@ public boolean shouldCache(Query query) throws IOException {
         when(searchContext.searcher()).thenReturn(contextIndexSearcher);
         when(searchContext.fetchPhase())
                 .thenReturn(new FetchPhase(Arrays.asList(new FetchSourceSubPhase(), new DocValueFieldsFetchSubPhase())));
+        when(searchContext.getObjectMapper(anyString())).thenAnswer(invocation -> {
+            String fieldName = (String) invocation.getArguments()[0];
+            if (fieldName.startsWith(NESTEDFIELD_PREFIX)) {
+                BuilderContext context = new BuilderContext(indexSettings.getSettings(), new ContentPath());
+                return new ObjectMapper.Builder<>(fieldName).nested(Nested.newNested(false, false)).build(context);
+            }
+            return null;
+        });
+        when(searchContext.bitsetFilterCache()).thenReturn(new BitsetFilterCache(indexSettings, mock(Listener.class)));
         doAnswer(invocation -> {
             /* Store the releasables so we can release them at the end of the test case. This is important because aggregations don't
              * close their sub-aggregations. This is fairly similar to what the production code does. */
@@ -157,6 +175,8 @@ protected QueryShardContext queryShardContextMock(MappedFieldType[] fieldTypes,
             when(queryShardContext.getForField(fieldType)).then(invocation -> fieldType.fielddataBuilder().build(indexSettings, fieldType,
                     new IndexFieldDataCache.None(), circuitBreakerService, mock(MapperService.class)));
         }
+        NestedScope nestedScope = new NestedScope();
+        when(queryShardContext.nestedScope()).thenReturn(nestedScope);
         return queryShardContext;
     }
 

core/src/test/java/org/elasticsearch/search/aggregations/bucket/nested/ReverseNestedAggregatorTests.java

@@ -0,0 +1,145 @@
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.elasticsearch.search.aggregations.bucket.nested;
+
+import org.apache.lucene.document.Document;
+import org.apache.lucene.document.Field;
+import org.apache.lucene.document.SortedNumericDocValuesField;
+import org.apache.lucene.index.DirectoryReader;
+import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.index.RandomIndexWriter;
+import org.apache.lucene.search.MatchAllDocsQuery;
+import org.apache.lucene.store.Directory;
+import org.elasticsearch.index.mapper.MappedFieldType;
+import org.elasticsearch.index.mapper.NumberFieldMapper;
+import org.elasticsearch.index.mapper.TypeFieldMapper;
+import org.elasticsearch.index.mapper.UidFieldMapper;
+import org.elasticsearch.search.aggregations.AggregatorTestCase;
+import org.elasticsearch.search.aggregations.metrics.max.InternalMax;
+import org.elasticsearch.search.aggregations.metrics.max.MaxAggregationBuilder;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+public class ReverseNestedAggregatorTests extends AggregatorTestCase {
+
+    private static final String VALUE_FIELD_NAME = "number";
+    private static final String NESTED_OBJECT = "nested_object";
+    private static final String NESTED_AGG = "nestedAgg";
+    private static final String REVERSE_AGG_NAME = "reverseNestedAgg";
+    private static final String MAX_AGG_NAME = "maxAgg";
+
+
+    public void testNoDocs() throws IOException {
+        try (Directory directory = newDirectory()) {
+            try (RandomIndexWriter iw = new RandomIndexWriter(random(), directory)) {
+                // intentionally not writing any docs
+            }
+            try (IndexReader indexReader = DirectoryReader.open(directory)) {
+                NestedAggregationBuilder nestedBuilder = new NestedAggregationBuilder(NESTED_AGG,
+                        NESTED_OBJECT);
+                ReverseNestedAggregationBuilder reverseNestedBuilder
+                    = new ReverseNestedAggregationBuilder(REVERSE_AGG_NAME);
+                nestedBuilder.subAggregation(reverseNestedBuilder);
+                MaxAggregationBuilder maxAgg = new MaxAggregationBuilder(MAX_AGG_NAME)
+                        .field(VALUE_FIELD_NAME);
+                reverseNestedBuilder.subAggregation(maxAgg);
+                MappedFieldType fieldType = new NumberFieldMapper.NumberFieldType(
+                        NumberFieldMapper.NumberType.LONG);
+                fieldType.setName(VALUE_FIELD_NAME);
+
+                Nested nested = search(newSearcher(indexReader, true, true),
+                        new MatchAllDocsQuery(), nestedBuilder, fieldType);
+                ReverseNested reverseNested = (ReverseNested) nested.getProperty(REVERSE_AGG_NAME);
+                assertEquals(REVERSE_AGG_NAME, reverseNested.getName());
+                assertEquals(0, reverseNested.getDocCount());
+
+                InternalMax max = (InternalMax) reverseNested.getProperty(MAX_AGG_NAME);
+                assertEquals(MAX_AGG_NAME, max.getName());
+                assertEquals(Double.NEGATIVE_INFINITY, max.getValue(), Double.MIN_VALUE);
+            }
+        }
+    }
+
+    public void testMaxFromParentDocs() throws IOException {
+        int numParentDocs = randomIntBetween(1, 20);
+        int expectedParentDocs = 0;
+        int expectedNestedDocs = 0;
+        double expectedMaxValue = Double.NEGATIVE_INFINITY;
+        try (Directory directory = newDirectory()) {
+            try (RandomIndexWriter iw = new RandomIndexWriter(random(), directory)) {
+                for (int i = 0; i < numParentDocs; i++) {
+                    List<Document> documents = new ArrayList<>();
+                    int numNestedDocs = randomIntBetween(0, 20);
+                    for (int nested = 0; nested < numNestedDocs; nested++) {
+                        Document document = new Document();
+                        document.add(new Field(UidFieldMapper.NAME, "type#" + i,
+                                UidFieldMapper.Defaults.NESTED_FIELD_TYPE));
+                        document.add(new Field(TypeFieldMapper.NAME, "__" + NESTED_OBJECT,
+                                TypeFieldMapper.Defaults.FIELD_TYPE));
+                        documents.add(document);
+                        expectedNestedDocs++;
+                    }
+                    Document document = new Document();
+                    document.add(new Field(UidFieldMapper.NAME, "type#" + i,
+                            UidFieldMapper.Defaults.FIELD_TYPE));
+                    document.add(new Field(TypeFieldMapper.NAME, "test",
+                            TypeFieldMapper.Defaults.FIELD_TYPE));
+                    long value = randomNonNegativeLong() % 10000;
+                    document.add(new SortedNumericDocValuesField(VALUE_FIELD_NAME, value));
+                    if (numNestedDocs > 0) {
+                        expectedMaxValue = Math.max(expectedMaxValue, value);
+                        expectedParentDocs++;
+                    }
+                    documents.add(document);
+                    iw.addDocuments(documents);
+                }
+                iw.commit();
+            }
+            try (IndexReader indexReader = DirectoryReader.open(directory)) {
+                NestedAggregationBuilder nestedBuilder = new NestedAggregationBuilder(NESTED_AGG,
+                        NESTED_OBJECT);
+                ReverseNestedAggregationBuilder reverseNestedBuilder
+                    = new ReverseNestedAggregationBuilder(REVERSE_AGG_NAME);
+                nestedBuilder.subAggregation(reverseNestedBuilder);
+                MaxAggregationBuilder maxAgg = new MaxAggregationBuilder(MAX_AGG_NAME)
+                        .field(VALUE_FIELD_NAME);
+                reverseNestedBuilder.subAggregation(maxAgg);
+                MappedFieldType fieldType = new NumberFieldMapper.NumberFieldType(
+                        NumberFieldMapper.NumberType.LONG);
+                fieldType.setName(VALUE_FIELD_NAME);
+
+                Nested nested = search(newSearcher(indexReader, true, true),
+                        new MatchAllDocsQuery(), nestedBuilder, fieldType);
+                assertEquals(expectedNestedDocs, nested.getDocCount());
+
+                ReverseNested reverseNested = (ReverseNested) nested.getProperty(REVERSE_AGG_NAME);
+                assertEquals(REVERSE_AGG_NAME, reverseNested.getName());
+                assertEquals(expectedParentDocs, reverseNested.getDocCount());
+
+                InternalMax max = (InternalMax) reverseNested.getProperty(MAX_AGG_NAME);
+                assertEquals(MAX_AGG_NAME, max.getName());
+                assertEquals(expectedMaxValue, max.getValue(), Double.MIN_VALUE);
+            }
+        }
+    }
+
+}