Remove explicit SearchResponse references from server bucket aggs (part3) (#102037)

server/src/internalClusterTest/java/org/elasticsearch/search/aggregations/bucket/IpRangeIT.java

@@ -8,7 +8,6 @@
 package org.elasticsearch.search.aggregations.bucket;
 
 import org.elasticsearch.action.search.SearchPhaseExecutionException;
-import org.elasticsearch.action.search.SearchResponse;
 import org.elasticsearch.cluster.health.ClusterHealthStatus;
 import org.elasticsearch.plugins.Plugin;
 import org.elasticsearch.script.MockScriptPlugin;
@@ -25,7 +24,7 @@ import java.util.Map;
 import java.util.function.Function;
 
 import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertAcked;
-import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertNoFailures;
+import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertNoFailuresAndResponse;
 import static org.hamcrest.Matchers.containsString;
 import static org.hamcrest.Matchers.instanceOf;
 
@@ -64,152 +63,167 @@ public class IpRangeIT extends ESIntegTestCase {
     }
 
     public void testSingleValuedField() {
-        SearchResponse rsp = prepareSearch("idx").addAggregation(
-            AggregationBuilders.ipRange("my_range")
-                .field("ip")
-                .addUnboundedTo("192.168.1.0")
-                .addRange("192.168.1.0", "192.168.1.10")
-                .addUnboundedFrom("192.168.1.10")
-        ).get();
-        assertNoFailures(rsp);
-        Range range = rsp.getAggregations().get("my_range");
-        assertEquals(3, range.getBuckets().size());
-
-        Range.Bucket bucket1 = range.getBuckets().get(0);
-        assertNull(bucket1.getFrom());
-        assertEquals("192.168.1.0", bucket1.getTo());
-        assertEquals("*-192.168.1.0", bucket1.getKey());
-        assertEquals(0, bucket1.getDocCount());
-
-        Range.Bucket bucket2 = range.getBuckets().get(1);
-        assertEquals("192.168.1.0", bucket2.getFrom());
-        assertEquals("192.168.1.10", bucket2.getTo());
-        assertEquals("192.168.1.0-192.168.1.10", bucket2.getKey());
-        assertEquals(1, bucket2.getDocCount());
-
-        Range.Bucket bucket3 = range.getBuckets().get(2);
-        assertEquals("192.168.1.10", bucket3.getFrom());
-        assertNull(bucket3.getTo());
-        assertEquals("192.168.1.10-*", bucket3.getKey());
-        assertEquals(2, bucket3.getDocCount());
+        assertNoFailuresAndResponse(
+            prepareSearch("idx").addAggregation(
+                AggregationBuilders.ipRange("my_range")
+                    .field("ip")
+                    .addUnboundedTo("192.168.1.0")
+                    .addRange("192.168.1.0", "192.168.1.10")
+                    .addUnboundedFrom("192.168.1.10")
+            ),
+            response -> {
+                Range range = response.getAggregations().get("my_range");
+                assertEquals(3, range.getBuckets().size());
+
+                Range.Bucket bucket1 = range.getBuckets().get(0);
+                assertNull(bucket1.getFrom());
+                assertEquals("192.168.1.0", bucket1.getTo());
+                assertEquals("*-192.168.1.0", bucket1.getKey());
+                assertEquals(0, bucket1.getDocCount());
+
+                Range.Bucket bucket2 = range.getBuckets().get(1);
+                assertEquals("192.168.1.0", bucket2.getFrom());
+                assertEquals("192.168.1.10", bucket2.getTo());
+                assertEquals("192.168.1.0-192.168.1.10", bucket2.getKey());
+                assertEquals(1, bucket2.getDocCount());
+
+                Range.Bucket bucket3 = range.getBuckets().get(2);
+                assertEquals("192.168.1.10", bucket3.getFrom());
+                assertNull(bucket3.getTo());
+                assertEquals("192.168.1.10-*", bucket3.getKey());
+                assertEquals(2, bucket3.getDocCount());
+            }
+        );
     }
 
     public void testMultiValuedField() {
-        SearchResponse rsp = prepareSearch("idx").addAggregation(
-            AggregationBuilders.ipRange("my_range")
-                .field("ips")
-                .addUnboundedTo("192.168.1.0")
-                .addRange("192.168.1.0", "192.168.1.10")
-                .addUnboundedFrom("192.168.1.10")
-        ).get();
-        assertNoFailures(rsp);
-        Range range = rsp.getAggregations().get("my_range");
-        assertEquals(3, range.getBuckets().size());
-
-        Range.Bucket bucket1 = range.getBuckets().get(0);
-        assertNull(bucket1.getFrom());
-        assertEquals("192.168.1.0", bucket1.getTo());
-        assertEquals("*-192.168.1.0", bucket1.getKey());
-        assertEquals(1, bucket1.getDocCount());
-
-        Range.Bucket bucket2 = range.getBuckets().get(1);
-        assertEquals("192.168.1.0", bucket2.getFrom());
-        assertEquals("192.168.1.10", bucket2.getTo());
-        assertEquals("192.168.1.0-192.168.1.10", bucket2.getKey());
-        assertEquals(1, bucket2.getDocCount());
-
-        Range.Bucket bucket3 = range.getBuckets().get(2);
-        assertEquals("192.168.1.10", bucket3.getFrom());
-        assertNull(bucket3.getTo());
-        assertEquals("192.168.1.10-*", bucket3.getKey());
-        assertEquals(2, bucket3.getDocCount());
+        assertNoFailuresAndResponse(
+            prepareSearch("idx").addAggregation(
+                AggregationBuilders.ipRange("my_range")
+                    .field("ips")
+                    .addUnboundedTo("192.168.1.0")
+                    .addRange("192.168.1.0", "192.168.1.10")
+                    .addUnboundedFrom("192.168.1.10")
+            ),
+            response -> {
+                Range range = response.getAggregations().get("my_range");
+                assertEquals(3, range.getBuckets().size());
+
+                Range.Bucket bucket1 = range.getBuckets().get(0);
+                assertNull(bucket1.getFrom());
+                assertEquals("192.168.1.0", bucket1.getTo());
+                assertEquals("*-192.168.1.0", bucket1.getKey());
+                assertEquals(1, bucket1.getDocCount());
+
+                Range.Bucket bucket2 = range.getBuckets().get(1);
+                assertEquals("192.168.1.0", bucket2.getFrom());
+                assertEquals("192.168.1.10", bucket2.getTo());
+                assertEquals("192.168.1.0-192.168.1.10", bucket2.getKey());
+                assertEquals(1, bucket2.getDocCount());
+
+                Range.Bucket bucket3 = range.getBuckets().get(2);
+                assertEquals("192.168.1.10", bucket3.getFrom());
+                assertNull(bucket3.getTo());
+                assertEquals("192.168.1.10-*", bucket3.getKey());
+                assertEquals(2, bucket3.getDocCount());
+            }
+        );
     }
 
     public void testIpMask() {
-        SearchResponse rsp = prepareSearch("idx").addAggregation(
-            AggregationBuilders.ipRange("my_range")
-                .field("ips")
-                .addMaskRange("::/0")
-                .addMaskRange("0.0.0.0/0")
-                .addMaskRange("2001:db8::/64")
-        ).get();
-        assertNoFailures(rsp);
-        Range range = rsp.getAggregations().get("my_range");
-        assertEquals(3, range.getBuckets().size());
-
-        Range.Bucket bucket1 = range.getBuckets().get(0);
-        assertEquals("::/0", bucket1.getKey());
-        assertEquals(3, bucket1.getDocCount());
-
-        Range.Bucket bucket2 = range.getBuckets().get(1);
-        assertEquals("0.0.0.0/0", bucket2.getKey());
-        assertEquals(2, bucket2.getDocCount());
-
-        Range.Bucket bucket3 = range.getBuckets().get(2);
-        assertEquals("2001:db8::/64", bucket3.getKey());
-        assertEquals(1, bucket3.getDocCount());
+        assertNoFailuresAndResponse(
+            prepareSearch("idx").addAggregation(
+                AggregationBuilders.ipRange("my_range")
+                    .field("ips")
+                    .addMaskRange("::/0")
+                    .addMaskRange("0.0.0.0/0")
+                    .addMaskRange("2001:db8::/64")
+            ),
+            response -> {
+                Range range = response.getAggregations().get("my_range");
+                assertEquals(3, range.getBuckets().size());
+
+                Range.Bucket bucket1 = range.getBuckets().get(0);
+                assertEquals("::/0", bucket1.getKey());
+                assertEquals(3, bucket1.getDocCount());
+
+                Range.Bucket bucket2 = range.getBuckets().get(1);
+                assertEquals("0.0.0.0/0", bucket2.getKey());
+                assertEquals(2, bucket2.getDocCount());
+
+                Range.Bucket bucket3 = range.getBuckets().get(2);
+                assertEquals("2001:db8::/64", bucket3.getKey());
+                assertEquals(1, bucket3.getDocCount());
+            }
+        );
     }
 
     public void testPartiallyUnmapped() {
-        SearchResponse rsp = prepareSearch("idx", "idx_unmapped").addAggregation(
-            AggregationBuilders.ipRange("my_range")
-                .field("ip")
-                .addUnboundedTo("192.168.1.0")
-                .addRange("192.168.1.0", "192.168.1.10")
-                .addUnboundedFrom("192.168.1.10")
-        ).get();
-        assertNoFailures(rsp);
-        Range range = rsp.getAggregations().get("my_range");
-        assertEquals(3, range.getBuckets().size());
-
-        Range.Bucket bucket1 = range.getBuckets().get(0);
-        assertNull(bucket1.getFrom());
-        assertEquals("192.168.1.0", bucket1.getTo());
-        assertEquals("*-192.168.1.0", bucket1.getKey());
-        assertEquals(0, bucket1.getDocCount());
-
-        Range.Bucket bucket2 = range.getBuckets().get(1);
-        assertEquals("192.168.1.0", bucket2.getFrom());
-        assertEquals("192.168.1.10", bucket2.getTo());
-        assertEquals("192.168.1.0-192.168.1.10", bucket2.getKey());
-        assertEquals(1, bucket2.getDocCount());
-
-        Range.Bucket bucket3 = range.getBuckets().get(2);
-        assertEquals("192.168.1.10", bucket3.getFrom());
-        assertNull(bucket3.getTo());
-        assertEquals("192.168.1.10-*", bucket3.getKey());
-        assertEquals(2, bucket3.getDocCount());
+        assertNoFailuresAndResponse(
+            prepareSearch("idx", "idx_unmapped").addAggregation(
+                AggregationBuilders.ipRange("my_range")
+                    .field("ip")
+                    .addUnboundedTo("192.168.1.0")
+                    .addRange("192.168.1.0", "192.168.1.10")
+                    .addUnboundedFrom("192.168.1.10")
+            ),
+            response -> {
+                Range range = response.getAggregations().get("my_range");
+                assertEquals(3, range.getBuckets().size());
+
+                Range.Bucket bucket1 = range.getBuckets().get(0);
+                assertNull(bucket1.getFrom());
+                assertEquals("192.168.1.0", bucket1.getTo());
+                assertEquals("*-192.168.1.0", bucket1.getKey());
+                assertEquals(0, bucket1.getDocCount());
+
+                Range.Bucket bucket2 = range.getBuckets().get(1);
+                assertEquals("192.168.1.0", bucket2.getFrom());
+                assertEquals("192.168.1.10", bucket2.getTo());
+                assertEquals("192.168.1.0-192.168.1.10", bucket2.getKey());
+                assertEquals(1, bucket2.getDocCount());
+
+                Range.Bucket bucket3 = range.getBuckets().get(2);
+                assertEquals("192.168.1.10", bucket3.getFrom());
+                assertNull(bucket3.getTo());
+                assertEquals("192.168.1.10-*", bucket3.getKey());
+                assertEquals(2, bucket3.getDocCount());
+            }
+        );
     }
 
     public void testUnmapped() {
-        SearchResponse rsp = prepareSearch("idx_unmapped").addAggregation(
-            AggregationBuilders.ipRange("my_range")
-                .field("ip")
-                .addUnboundedTo("192.168.1.0")
-                .addRange("192.168.1.0", "192.168.1.10")
-                .addUnboundedFrom("192.168.1.10")
-        ).get();
-        assertNoFailures(rsp);
-        Range range = rsp.getAggregations().get("my_range");
-        assertEquals(3, range.getBuckets().size());
-
-        Range.Bucket bucket1 = range.getBuckets().get(0);
-        assertNull(bucket1.getFrom());
-        assertEquals("192.168.1.0", bucket1.getTo());
-        assertEquals("*-192.168.1.0", bucket1.getKey());
-        assertEquals(0, bucket1.getDocCount());
-
-        Range.Bucket bucket2 = range.getBuckets().get(1);
-        assertEquals("192.168.1.0", bucket2.getFrom());
-        assertEquals("192.168.1.10", bucket2.getTo());
-        assertEquals("192.168.1.0-192.168.1.10", bucket2.getKey());
-        assertEquals(0, bucket2.getDocCount());
-
-        Range.Bucket bucket3 = range.getBuckets().get(2);
-        assertEquals("192.168.1.10", bucket3.getFrom());
-        assertNull(bucket3.getTo());
-        assertEquals("192.168.1.10-*", bucket3.getKey());
-        assertEquals(0, bucket3.getDocCount());
+        assertNoFailuresAndResponse(
+            prepareSearch("idx_unmapped").addAggregation(
+                AggregationBuilders.ipRange("my_range")
+                    .field("ip")
+                    .addUnboundedTo("192.168.1.0")
+                    .addRange("192.168.1.0", "192.168.1.10")
+                    .addUnboundedFrom("192.168.1.10")
+            ),
+            response -> {
+                Range range = response.getAggregations().get("my_range");
+                assertEquals(3, range.getBuckets().size());
+
+                Range.Bucket bucket1 = range.getBuckets().get(0);
+                assertNull(bucket1.getFrom());
+                assertEquals("192.168.1.0", bucket1.getTo());
+                assertEquals("*-192.168.1.0", bucket1.getKey());
+                assertEquals(0, bucket1.getDocCount());
+
+                Range.Bucket bucket2 = range.getBuckets().get(1);
+                assertEquals("192.168.1.0", bucket2.getFrom());
+                assertEquals("192.168.1.10", bucket2.getTo());
+                assertEquals("192.168.1.0-192.168.1.10", bucket2.getKey());
+                assertEquals(0, bucket2.getDocCount());
+
+                Range.Bucket bucket3 = range.getBuckets().get(2);
+                assertEquals("192.168.1.10", bucket3.getFrom());
+                assertNull(bucket3.getTo());
+                assertEquals("192.168.1.10-*", bucket3.getKey());
+                assertEquals(0, bucket3.getDocCount());
+            }
+        );
     }
 
     public void testRejectsScript() {

server/src/internalClusterTest/java/org/elasticsearch/search/aggregations/bucket/IpTermsIT.java

@@ -7,7 +7,6 @@
  */
 package org.elasticsearch.search.aggregations.bucket;
 
-import org.elasticsearch.action.search.SearchResponse;
 import org.elasticsearch.index.fielddata.ScriptDocValues;
 import org.elasticsearch.plugins.Plugin;
 import org.elasticsearch.script.Script;
@@ -22,7 +21,7 @@ import java.util.Map;
 import java.util.function.Function;
 
 import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertAcked;
-import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertNoFailures;
+import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertNoFailuresAndResponse;
 
 public class IpTermsIT extends AbstractTermsTestCase {
 
@@ -61,22 +60,25 @@ public class IpTermsIT extends AbstractTermsTestCase {
         );
 
         Script script = new Script(ScriptType.INLINE, CustomScriptPlugin.NAME, "doc['ip'].value", Collections.emptyMap());
-        SearchResponse response = prepareSearch("index").addAggregation(
-            new TermsAggregationBuilder("my_terms").script(script).executionHint(randomExecutionHint())
-        ).get();
-        assertNoFailures(response);
-        StringTerms terms = response.getAggregations().get("my_terms");
-        assertEquals(2, terms.getBuckets().size());
-
-        StringTerms.Bucket bucket1 = terms.getBuckets().get(0);
-        assertEquals(2, bucket1.getDocCount());
-        assertEquals("192.168.1.7", bucket1.getKey());
-        assertEquals("192.168.1.7", bucket1.getKeyAsString());
-
-        StringTerms.Bucket bucket2 = terms.getBuckets().get(1);
-        assertEquals(1, bucket2.getDocCount());
-        assertEquals("2001:db8::2:1", bucket2.getKey());
-        assertEquals("2001:db8::2:1", bucket2.getKeyAsString());
+        assertNoFailuresAndResponse(
+            prepareSearch("index").addAggregation(
+                new TermsAggregationBuilder("my_terms").script(script).executionHint(randomExecutionHint())
+            ),
+            response -> {
+                StringTerms terms = response.getAggregations().get("my_terms");
+                assertEquals(2, terms.getBuckets().size());
+
+                StringTerms.Bucket bucket1 = terms.getBuckets().get(0);
+                assertEquals(2, bucket1.getDocCount());
+                assertEquals("192.168.1.7", bucket1.getKey());
+                assertEquals("192.168.1.7", bucket1.getKeyAsString());
+
+                StringTerms.Bucket bucket2 = terms.getBuckets().get(1);
+                assertEquals(1, bucket2.getDocCount());
+                assertEquals("2001:db8::2:1", bucket2.getKey());
+                assertEquals("2001:db8::2:1", bucket2.getKeyAsString());
+            }
+        );
     }
 
     public void testScriptValues() throws Exception {
@@ -89,22 +91,25 @@ public class IpTermsIT extends AbstractTermsTestCase {
         );
 
         Script script = new Script(ScriptType.INLINE, CustomScriptPlugin.NAME, "doc['ip']", Collections.emptyMap());
-        SearchResponse response = prepareSearch("index").addAggregation(
-            new TermsAggregationBuilder("my_terms").script(script).executionHint(randomExecutionHint())
-        ).get();
-        assertNoFailures(response);
-        StringTerms terms = response.getAggregations().get("my_terms");
-        assertEquals(2, terms.getBuckets().size());
-
-        StringTerms.Bucket bucket1 = terms.getBuckets().get(0);
-        assertEquals(2, bucket1.getDocCount());
-        assertEquals("192.168.1.7", bucket1.getKey());
-        assertEquals("192.168.1.7", bucket1.getKeyAsString());
-
-        StringTerms.Bucket bucket2 = terms.getBuckets().get(1);
-        assertEquals(1, bucket2.getDocCount());
-        assertEquals("2001:db8::2:1", bucket2.getKey());
-        assertEquals("2001:db8::2:1", bucket2.getKeyAsString());
+        assertNoFailuresAndResponse(
+            prepareSearch("index").addAggregation(
+                new TermsAggregationBuilder("my_terms").script(script).executionHint(randomExecutionHint())
+            ),
+            response -> {
+                StringTerms terms = response.getAggregations().get("my_terms");
+                assertEquals(2, terms.getBuckets().size());
+
+                StringTerms.Bucket bucket1 = terms.getBuckets().get(0);
+                assertEquals(2, bucket1.getDocCount());
+                assertEquals("192.168.1.7", bucket1.getKey());
+                assertEquals("192.168.1.7", bucket1.getKeyAsString());
+
+                StringTerms.Bucket bucket2 = terms.getBuckets().get(1);
+                assertEquals(1, bucket2.getDocCount());
+                assertEquals("2001:db8::2:1", bucket2.getKey());
+                assertEquals("2001:db8::2:1", bucket2.getKeyAsString());
+            }
+        );
     }
 
     public void testMissingValue() throws Exception {
@@ -116,22 +121,24 @@ public class IpTermsIT extends AbstractTermsTestCase {
             client().prepareIndex("index").setId("3").setSource("ip", "127.0.0.1"),
             client().prepareIndex("index").setId("4").setSource("not_ip", "something")
         );
-        SearchResponse response = prepareSearch("index").addAggregation(
-            new TermsAggregationBuilder("my_terms").field("ip").missing("127.0.0.1").executionHint(randomExecutionHint())
-        ).get();
-
-        assertNoFailures(response);
-        StringTerms terms = response.getAggregations().get("my_terms");
-        assertEquals(2, terms.getBuckets().size());
-
-        StringTerms.Bucket bucket1 = terms.getBuckets().get(0);
-        assertEquals(2, bucket1.getDocCount());
-        assertEquals("127.0.0.1", bucket1.getKey());
-        assertEquals("127.0.0.1", bucket1.getKeyAsString());
-
-        StringTerms.Bucket bucket2 = terms.getBuckets().get(1);
-        assertEquals(2, bucket2.getDocCount());
-        assertEquals("192.168.1.7", bucket2.getKey());
-        assertEquals("192.168.1.7", bucket2.getKeyAsString());
+        assertNoFailuresAndResponse(
+            prepareSearch("index").addAggregation(
+                new TermsAggregationBuilder("my_terms").field("ip").missing("127.0.0.1").executionHint(randomExecutionHint())
+            ),
+            response -> {
+                StringTerms terms = response.getAggregations().get("my_terms");
+                assertEquals(2, terms.getBuckets().size());
+
+                StringTerms.Bucket bucket1 = terms.getBuckets().get(0);
+                assertEquals(2, bucket1.getDocCount());
+                assertEquals("127.0.0.1", bucket1.getKey());
+                assertEquals("127.0.0.1", bucket1.getKeyAsString());
+
+                StringTerms.Bucket bucket2 = terms.getBuckets().get(1);
+                assertEquals(2, bucket2.getDocCount());
+                assertEquals("192.168.1.7", bucket2.getKey());
+                assertEquals("192.168.1.7", bucket2.getKeyAsString());
+            }
+        );
     }
 }

server/src/internalClusterTest/java/org/elasticsearch/search/aggregations/bucket/LongTermsIT.java

@@ -9,7 +9,6 @@ package org.elasticsearch.search.aggregations.bucket;
 
 import org.elasticsearch.ElasticsearchException;
 import org.elasticsearch.action.index.IndexRequestBuilder;
-import org.elasticsearch.action.search.SearchResponse;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.core.Strings;
 import org.elasticsearch.index.fielddata.ScriptDocValues;
@@ -54,6 +53,7 @@ import static org.elasticsearch.search.aggregations.AggregationBuilders.stats;
 import static org.elasticsearch.search.aggregations.AggregationBuilders.sum;
 import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertAcked;
 import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertNoFailures;
+import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertNoFailuresAndResponse;
 import static org.elasticsearch.xcontent.XContentFactory.jsonBuilder;
 import static org.hamcrest.Matchers.containsString;
 import static org.hamcrest.Matchers.equalTo;
@@ -263,108 +263,119 @@ public class LongTermsIT extends AbstractTermsTestCase {
 
     private void runTestFieldWithPartitionedFiltering(String field) throws Exception {
         // Find total number of unique terms
-        SearchResponse allResponse = prepareSearch("idx").addAggregation(
-            new TermsAggregationBuilder("terms").field(field).collectMode(randomFrom(SubAggCollectionMode.values()))
-        ).get();
-        assertNoFailures(allResponse);
-        LongTerms terms = allResponse.getAggregations().get("terms");
-        assertThat(terms, notNullValue());
-        assertThat(terms.getName(), equalTo("terms"));
-        int expectedCardinality = terms.getBuckets().size();
+        int[] expectedCardinality = new int[1];
+        assertNoFailuresAndResponse(
+            prepareSearch("idx").addAggregation(
+                new TermsAggregationBuilder("terms").field(field).collectMode(randomFrom(SubAggCollectionMode.values()))
+            ),
+            response -> {
+                assertNoFailures(response);
+                LongTerms terms = response.getAggregations().get("terms");
+                assertThat(terms, notNullValue());
+                assertThat(terms.getName(), equalTo("terms"));
+                expectedCardinality[0] = terms.getBuckets().size();
+            }
+        );
 
         // Gather terms using partitioned aggregations
         final int numPartitions = randomIntBetween(2, 4);
         Set<Number> foundTerms = new HashSet<>();
         for (int partition = 0; partition < numPartitions; partition++) {
-            SearchResponse response = prepareSearch("idx").addAggregation(
-                new TermsAggregationBuilder("terms").field(field)
-                    .includeExclude(new IncludeExclude(partition, numPartitions))
-                    .collectMode(randomFrom(SubAggCollectionMode.values()))
-            ).get();
-            assertNoFailures(response);
-            terms = response.getAggregations().get("terms");
-            assertThat(terms, notNullValue());
-            assertThat(terms.getName(), equalTo("terms"));
-            for (LongTerms.Bucket bucket : terms.getBuckets()) {
-                assertFalse(foundTerms.contains(bucket.getKeyAsNumber()));
-                foundTerms.add(bucket.getKeyAsNumber());
-            }
+            assertNoFailuresAndResponse(
+                prepareSearch("idx").addAggregation(
+                    new TermsAggregationBuilder("terms").field(field)
+                        .includeExclude(new IncludeExclude(partition, numPartitions))
+                        .collectMode(randomFrom(SubAggCollectionMode.values()))
+                ),
+                response -> {
+                    LongTerms terms = response.getAggregations().get("terms");
+                    assertThat(terms, notNullValue());
+                    assertThat(terms.getName(), equalTo("terms"));
+                    for (LongTerms.Bucket bucket : terms.getBuckets()) {
+                        assertFalse(foundTerms.contains(bucket.getKeyAsNumber()));
+                        foundTerms.add(bucket.getKeyAsNumber());
+                    }
+                }
+            );
         }
-        assertEquals(expectedCardinality, foundTerms.size());
+        assertEquals(expectedCardinality[0], foundTerms.size());
     }
 
     public void testSingleValuedFieldWithValueScript() throws Exception {
-        SearchResponse response = prepareSearch("idx").addAggregation(
-            new TermsAggregationBuilder("terms").field(SINGLE_VALUED_FIELD_NAME)
-                .collectMode(randomFrom(SubAggCollectionMode.values()))
-                .script(new Script(ScriptType.INLINE, CustomScriptPlugin.NAME, "_value + 1", Collections.emptyMap()))
-        ).get();
-
-        assertNoFailures(response);
-
-        // Scripts force the results to doubles
-        DoubleTerms terms = response.getAggregations().get("terms");
-        assertThat(terms, notNullValue());
-        assertThat(terms.getName(), equalTo("terms"));
-        assertThat(terms.getBuckets().size(), equalTo(5));
-
-        for (int i = 0; i < 5; i++) {
-            DoubleTerms.Bucket bucket = terms.getBucketByKey("" + (i + 1d));
-            assertThat(bucket, notNullValue());
-            assertThat(bucket.getKeyAsString(), equalTo("" + (i + 1d)));
-            assertThat(bucket.getKeyAsNumber().intValue(), equalTo(i + 1));
-            assertThat(bucket.getDocCount(), equalTo(1L));
-        }
+        assertNoFailuresAndResponse(
+            prepareSearch("idx").addAggregation(
+                new TermsAggregationBuilder("terms").field(SINGLE_VALUED_FIELD_NAME)
+                    .collectMode(randomFrom(SubAggCollectionMode.values()))
+                    .script(new Script(ScriptType.INLINE, CustomScriptPlugin.NAME, "_value + 1", Collections.emptyMap()))
+            ),
+            response -> {
+                // Scripts force the results to doubles
+                DoubleTerms terms = response.getAggregations().get("terms");
+                assertThat(terms, notNullValue());
+                assertThat(terms.getName(), equalTo("terms"));
+                assertThat(terms.getBuckets().size(), equalTo(5));
+
+                for (int i = 0; i < 5; i++) {
+                    DoubleTerms.Bucket bucket = terms.getBucketByKey("" + (i + 1d));
+                    assertThat(bucket, notNullValue());
+                    assertThat(bucket.getKeyAsString(), equalTo("" + (i + 1d)));
+                    assertThat(bucket.getKeyAsNumber().intValue(), equalTo(i + 1));
+                    assertThat(bucket.getDocCount(), equalTo(1L));
+                }
+            }
+        );
     }
 
     public void testMultiValuedFieldWithValueScript() throws Exception {
-        SearchResponse response = prepareSearch("idx").addAggregation(
-            new TermsAggregationBuilder("terms").field(MULTI_VALUED_FIELD_NAME)
-                .collectMode(randomFrom(SubAggCollectionMode.values()))
-                .script(new Script(ScriptType.INLINE, CustomScriptPlugin.NAME, "_value - 1", Collections.emptyMap()))
-        ).get();
-
-        assertNoFailures(response);
-
-        // Scripts force the results to doubles
-        DoubleTerms terms = response.getAggregations().get("terms");
-        assertThat(terms, notNullValue());
-        assertThat(terms.getName(), equalTo("terms"));
-        assertThat(terms.getBuckets().size(), equalTo(6));
-
-        for (int i = 0; i < 6; i++) {
-            DoubleTerms.Bucket bucket = terms.getBucketByKey("" + (i - 1d));
-            assertThat(bucket, notNullValue());
-            assertThat(bucket.getKeyAsString(), equalTo("" + (i - 1d)));
-            assertThat(bucket.getKeyAsNumber().intValue(), equalTo(i - 1));
-            if (i == 0 || i == 5) {
-                assertThat(bucket.getDocCount(), equalTo(1L));
-            } else {
-                assertThat(bucket.getDocCount(), equalTo(2L));
+        assertNoFailuresAndResponse(
+            prepareSearch("idx").addAggregation(
+                new TermsAggregationBuilder("terms").field(MULTI_VALUED_FIELD_NAME)
+                    .collectMode(randomFrom(SubAggCollectionMode.values()))
+                    .script(new Script(ScriptType.INLINE, CustomScriptPlugin.NAME, "_value - 1", Collections.emptyMap()))
+            ),
+            response -> {
+                // Scripts force the results to doubles
+                DoubleTerms terms = response.getAggregations().get("terms");
+                assertThat(terms, notNullValue());
+                assertThat(terms.getName(), equalTo("terms"));
+                assertThat(terms.getBuckets().size(), equalTo(6));
+
+                for (int i = 0; i < 6; i++) {
+                    DoubleTerms.Bucket bucket = terms.getBucketByKey("" + (i - 1d));
+                    assertThat(bucket, notNullValue());
+                    assertThat(bucket.getKeyAsString(), equalTo("" + (i - 1d)));
+                    assertThat(bucket.getKeyAsNumber().intValue(), equalTo(i - 1));
+                    if (i == 0 || i == 5) {
+                        assertThat(bucket.getDocCount(), equalTo(1L));
+                    } else {
+                        assertThat(bucket.getDocCount(), equalTo(2L));
+                    }
+                }
             }
-        }
+        );
     }
 
     public void testMultiValuedFieldWithValueScriptNotUnique() throws Exception {
-        SearchResponse response = prepareSearch("idx").addAggregation(
-            new TermsAggregationBuilder("terms").field(MULTI_VALUED_FIELD_NAME)
-                .collectMode(randomFrom(SubAggCollectionMode.values()))
-                .script(new Script(ScriptType.INLINE, CustomScriptPlugin.NAME, "floor(_value / 1000 + 1)", Collections.emptyMap()))
-        ).get();
-
-        assertNoFailures(response);
-
-        // The script always converts long to double
-        DoubleTerms terms = response.getAggregations().get("terms");
-        assertThat(terms, notNullValue());
-        assertThat(terms.getName(), equalTo("terms"));
-        assertThat(terms.getBuckets().size(), equalTo(1));
-
-        DoubleTerms.Bucket bucket = terms.getBucketByKey("1.0");
-        assertThat(bucket, notNullValue());
-        assertThat(bucket.getKeyAsString(), equalTo("1.0"));
-        assertThat(bucket.getKeyAsNumber().intValue(), equalTo(1));
-        assertThat(bucket.getDocCount(), equalTo(5L));
+        assertNoFailuresAndResponse(
+            prepareSearch("idx").addAggregation(
+                new TermsAggregationBuilder("terms").field(MULTI_VALUED_FIELD_NAME)
+                    .collectMode(randomFrom(SubAggCollectionMode.values()))
+                    .script(new Script(ScriptType.INLINE, CustomScriptPlugin.NAME, "floor(_value / 1000 + 1)", Collections.emptyMap()))
+            ),
+            response -> {
+                // The script always converts long to double
+                DoubleTerms terms = response.getAggregations().get("terms");
+                assertThat(terms, notNullValue());
+                assertThat(terms.getName(), equalTo("terms"));
+                assertThat(terms.getBuckets().size(), equalTo(1));
+
+                DoubleTerms.Bucket bucket = terms.getBucketByKey("1.0");
+                assertThat(bucket, notNullValue());
+                assertThat(bucket.getKeyAsString(), equalTo("1.0"));
+                assertThat(bucket.getKeyAsNumber().intValue(), equalTo(1));
+                assertThat(bucket.getDocCount(), equalTo(5L));
+            }
+        );
     }
 
     /*
@@ -392,27 +403,28 @@ public class LongTermsIT extends AbstractTermsTestCase {
             Collections.emptyMap()
         );
 
-        SearchResponse response = prepareSearch("idx").addAggregation(
-            new TermsAggregationBuilder("terms").collectMode(randomFrom(SubAggCollectionMode.values()))
-                .userValueTypeHint(ValueType.LONG)
-                .script(script)
-        ).get();
-
-        assertNoFailures(response);
-
-        LongTerms terms = response.getAggregations().get("terms");
-        assertThat(terms, notNullValue());
-        assertThat(terms.getName(), equalTo("terms"));
-        assertThat(terms.getBuckets().size(), equalTo(5));
-
-        for (int i = 0; i < 5; i++) {
-            LongTerms.Bucket bucket = terms.getBucketByKey("" + i);
-            assertThat(bucket, notNullValue());
-            assertThat(bucket.getKeyAsString(), equalTo("" + i));
-            assertThat(bucket.getKeyAsNumber().intValue(), equalTo(i));
-            assertThat(bucket.getKeyAsNumber(), instanceOf(Long.class));
-            assertThat(bucket.getDocCount(), equalTo(1L));
-        }
+        assertNoFailuresAndResponse(
+            prepareSearch("idx").addAggregation(
+                new TermsAggregationBuilder("terms").collectMode(randomFrom(SubAggCollectionMode.values()))
+                    .userValueTypeHint(ValueType.LONG)
+                    .script(script)
+            ),
+            response -> {
+                LongTerms terms = response.getAggregations().get("terms");
+                assertThat(terms, notNullValue());
+                assertThat(terms.getName(), equalTo("terms"));
+                assertThat(terms.getBuckets().size(), equalTo(5));
+
+                for (int i = 0; i < 5; i++) {
+                    LongTerms.Bucket bucket = terms.getBucketByKey("" + i);
+                    assertThat(bucket, notNullValue());
+                    assertThat(bucket.getKeyAsString(), equalTo("" + i));
+                    assertThat(bucket.getKeyAsNumber().intValue(), equalTo(i));
+                    assertThat(bucket.getKeyAsNumber(), instanceOf(Long.class));
+                    assertThat(bucket.getDocCount(), equalTo(1L));
+                }
+            }
+        );
     }
 
     public void testScriptMultiValued() throws Exception {
@@ -423,207 +435,213 @@ public class LongTermsIT extends AbstractTermsTestCase {
             Collections.emptyMap()
         );
 
-        SearchResponse response = prepareSearch("idx").addAggregation(
-            new TermsAggregationBuilder("terms").collectMode(randomFrom(SubAggCollectionMode.values()))
-                .userValueTypeHint(ValueType.LONG)
-                .script(script)
-        ).get();
-
-        assertNoFailures(response);
-
-        LongTerms terms = response.getAggregations().get("terms");
-        assertThat(terms, notNullValue());
-        assertThat(terms.getName(), equalTo("terms"));
-        assertThat(terms.getBuckets().size(), equalTo(6));
-
-        for (int i = 0; i < 6; i++) {
-            LongTerms.Bucket bucket = terms.getBucketByKey("" + i);
-            assertThat(bucket, notNullValue());
-            assertThat(bucket.getKeyAsString(), equalTo("" + i));
-            assertThat(bucket.getKeyAsNumber().intValue(), equalTo(i));
-            if (i == 0 || i == 5) {
-                assertThat(bucket.getDocCount(), equalTo(1L));
-            } else {
-                assertThat(bucket.getDocCount(), equalTo(2L));
+        assertNoFailuresAndResponse(
+            prepareSearch("idx").addAggregation(
+                new TermsAggregationBuilder("terms").collectMode(randomFrom(SubAggCollectionMode.values()))
+                    .userValueTypeHint(ValueType.LONG)
+                    .script(script)
+            ),
+            response -> {
+                LongTerms terms = response.getAggregations().get("terms");
+                assertThat(terms, notNullValue());
+                assertThat(terms.getName(), equalTo("terms"));
+                assertThat(terms.getBuckets().size(), equalTo(6));
+
+                for (int i = 0; i < 6; i++) {
+                    LongTerms.Bucket bucket = terms.getBucketByKey("" + i);
+                    assertThat(bucket, notNullValue());
+                    assertThat(bucket.getKeyAsString(), equalTo("" + i));
+                    assertThat(bucket.getKeyAsNumber().intValue(), equalTo(i));
+                    if (i == 0 || i == 5) {
+                        assertThat(bucket.getDocCount(), equalTo(1L));
+                    } else {
+                        assertThat(bucket.getDocCount(), equalTo(2L));
+                    }
+                }
             }
-        }
+        );
     }
 
     public void testPartiallyUnmapped() throws Exception {
-        SearchResponse response = prepareSearch("idx_unmapped", "idx").addAggregation(
-            new TermsAggregationBuilder("terms").field(SINGLE_VALUED_FIELD_NAME).collectMode(randomFrom(SubAggCollectionMode.values()))
-        ).get();
-
-        assertNoFailures(response);
-
-        LongTerms terms = response.getAggregations().get("terms");
-        assertThat(terms, notNullValue());
-        assertThat(terms.getName(), equalTo("terms"));
-        assertThat(terms.getBuckets().size(), equalTo(5));
-
-        for (int i = 0; i < 5; i++) {
-            LongTerms.Bucket bucket = terms.getBucketByKey("" + i);
-            assertThat(bucket, notNullValue());
-            assertThat(bucket.getKeyAsString(), equalTo("" + i));
-            assertThat(bucket.getKeyAsNumber().intValue(), equalTo(i));
-            assertThat(bucket.getDocCount(), equalTo(1L));
-        }
+        assertNoFailuresAndResponse(
+            prepareSearch("idx_unmapped", "idx").addAggregation(
+                new TermsAggregationBuilder("terms").field(SINGLE_VALUED_FIELD_NAME).collectMode(randomFrom(SubAggCollectionMode.values()))
+            ),
+            response -> {
+                LongTerms terms = response.getAggregations().get("terms");
+                assertThat(terms, notNullValue());
+                assertThat(terms.getName(), equalTo("terms"));
+                assertThat(terms.getBuckets().size(), equalTo(5));
+
+                for (int i = 0; i < 5; i++) {
+                    LongTerms.Bucket bucket = terms.getBucketByKey("" + i);
+                    assertThat(bucket, notNullValue());
+                    assertThat(bucket.getKeyAsString(), equalTo("" + i));
+                    assertThat(bucket.getKeyAsNumber().intValue(), equalTo(i));
+                    assertThat(bucket.getDocCount(), equalTo(1L));
+                }
+            }
+        );
     }
 
     public void testPartiallyUnmappedWithFormat() throws Exception {
-        SearchResponse response = prepareSearch("idx_unmapped", "idx").addAggregation(
-            new TermsAggregationBuilder("terms").field(SINGLE_VALUED_FIELD_NAME)
-                .collectMode(randomFrom(SubAggCollectionMode.values()))
-                .format("0000")
-        ).get();
-
-        assertNoFailures(response);
-
-        LongTerms terms = response.getAggregations().get("terms");
-        assertThat(terms, notNullValue());
-        assertThat(terms.getName(), equalTo("terms"));
-        assertThat(terms.getBuckets().size(), equalTo(5));
-
-        for (int i = 0; i < 5; i++) {
-            String key = Strings.format("%04d", i);
-            LongTerms.Bucket bucket = terms.getBucketByKey(key);
-            assertThat(bucket, notNullValue());
-            assertThat(bucket.getKeyAsString(), equalTo(key));
-            assertThat(bucket.getKeyAsNumber().intValue(), equalTo(i));
-            assertThat(bucket.getDocCount(), equalTo(1L));
-        }
+        assertNoFailuresAndResponse(
+            prepareSearch("idx_unmapped", "idx").addAggregation(
+                new TermsAggregationBuilder("terms").field(SINGLE_VALUED_FIELD_NAME)
+                    .collectMode(randomFrom(SubAggCollectionMode.values()))
+                    .format("0000")
+            ),
+            response -> {
+                LongTerms terms = response.getAggregations().get("terms");
+                assertThat(terms, notNullValue());
+                assertThat(terms.getName(), equalTo("terms"));
+                assertThat(terms.getBuckets().size(), equalTo(5));
+
+                for (int i = 0; i < 5; i++) {
+                    String key = Strings.format("%04d", i);
+                    LongTerms.Bucket bucket = terms.getBucketByKey(key);
+                    assertThat(bucket, notNullValue());
+                    assertThat(bucket.getKeyAsString(), equalTo(key));
+                    assertThat(bucket.getKeyAsNumber().intValue(), equalTo(i));
+                    assertThat(bucket.getDocCount(), equalTo(1L));
+                }
+            }
+        );
     }
 
     public void testSingleValuedFieldOrderedBySingleValueSubAggregationAscWithTermsSubAgg() throws Exception {
         boolean asc = true;
-        SearchResponse response = prepareSearch("idx").addAggregation(
-            new TermsAggregationBuilder("terms").field(SINGLE_VALUED_FIELD_NAME)
-                .collectMode(randomFrom(SubAggCollectionMode.values()))
-                .order(BucketOrder.aggregation("avg_i", asc))
-                .subAggregation(avg("avg_i").field(SINGLE_VALUED_FIELD_NAME))
-                .subAggregation(
-                    new TermsAggregationBuilder("subTerms").field(MULTI_VALUED_FIELD_NAME)
-                        .collectMode(randomFrom(SubAggCollectionMode.values()))
-                )
-        ).get();
-
-        assertNoFailures(response);
-
-        LongTerms terms = response.getAggregations().get("terms");
-        assertThat(terms, notNullValue());
-        assertThat(terms.getName(), equalTo("terms"));
-        assertThat(terms.getBuckets().size(), equalTo(5));
-
-        for (int i = 0; i < 5; i++) {
-            LongTerms.Bucket bucket = terms.getBucketByKey("" + i);
-            assertThat(bucket, notNullValue());
-            assertThat(bucket.getKeyAsString(), equalTo("" + i));
-            assertThat(bucket.getDocCount(), equalTo(1L));
-
-            Avg avg = bucket.getAggregations().get("avg_i");
-            assertThat(avg, notNullValue());
-            assertThat(avg.getValue(), equalTo((double) i));
-
-            LongTerms subTermsAgg = bucket.getAggregations().get("subTerms");
-            assertThat(subTermsAgg, notNullValue());
-            assertThat(subTermsAgg.getBuckets().size(), equalTo(2));
-            int j = i;
-            for (LongTerms.Bucket subBucket : subTermsAgg.getBuckets()) {
-                assertThat(subBucket, notNullValue());
-                assertThat(subBucket.getKeyAsString(), equalTo(String.valueOf(j)));
-                assertThat(subBucket.getDocCount(), equalTo(1L));
-                j++;
+        assertNoFailuresAndResponse(
+            prepareSearch("idx").addAggregation(
+                new TermsAggregationBuilder("terms").field(SINGLE_VALUED_FIELD_NAME)
+                    .collectMode(randomFrom(SubAggCollectionMode.values()))
+                    .order(BucketOrder.aggregation("avg_i", asc))
+                    .subAggregation(avg("avg_i").field(SINGLE_VALUED_FIELD_NAME))
+                    .subAggregation(
+                        new TermsAggregationBuilder("subTerms").field(MULTI_VALUED_FIELD_NAME)
+                            .collectMode(randomFrom(SubAggCollectionMode.values()))
+                    )
+            ),
+            response -> {
+                LongTerms terms = response.getAggregations().get("terms");
+                assertThat(terms, notNullValue());
+                assertThat(terms.getName(), equalTo("terms"));
+                assertThat(terms.getBuckets().size(), equalTo(5));
+
+                for (int i = 0; i < 5; i++) {
+                    LongTerms.Bucket bucket = terms.getBucketByKey("" + i);
+                    assertThat(bucket, notNullValue());
+                    assertThat(bucket.getKeyAsString(), equalTo("" + i));
+                    assertThat(bucket.getDocCount(), equalTo(1L));
+
+                    Avg avg = bucket.getAggregations().get("avg_i");
+                    assertThat(avg, notNullValue());
+                    assertThat(avg.getValue(), equalTo((double) i));
+
+                    LongTerms subTermsAgg = bucket.getAggregations().get("subTerms");
+                    assertThat(subTermsAgg, notNullValue());
+                    assertThat(subTermsAgg.getBuckets().size(), equalTo(2));
+                    int j = i;
+                    for (LongTerms.Bucket subBucket : subTermsAgg.getBuckets()) {
+                        assertThat(subBucket, notNullValue());
+                        assertThat(subBucket.getKeyAsString(), equalTo(String.valueOf(j)));
+                        assertThat(subBucket.getDocCount(), equalTo(1L));
+                        j++;
+                    }
+                }
             }
-        }
+        );
     }
 
     public void testSingleValuedFieldOrderedBySingleBucketSubAggregationAsc() throws Exception {
         boolean asc = randomBoolean();
-        SearchResponse response = prepareSearch("idx").addAggregation(
-            new TermsAggregationBuilder("num_tags").field("num_tag")
-                .collectMode(randomFrom(SubAggCollectionMode.values()))
-                .order(BucketOrder.aggregation("filter", asc))
-                .subAggregation(filter("filter", QueryBuilders.matchAllQuery()))
-        ).get();
-
-        assertNoFailures(response);
-
-        LongTerms tags = response.getAggregations().get("num_tags");
-        assertThat(tags, notNullValue());
-        assertThat(tags.getName(), equalTo("num_tags"));
-        assertThat(tags.getBuckets().size(), equalTo(2));
-
-        Iterator<LongTerms.Bucket> iters = tags.getBuckets().iterator();
-
-        LongTerms.Bucket tag = iters.next();
-        assertThat(tag, notNullValue());
-        assertThat(tag.getKeyAsString(), equalTo(asc ? "0" : "1"));
-        assertThat(tag.getDocCount(), equalTo(asc ? 2L : 3L));
-        Filter filter = tag.getAggregations().get("filter");
-        assertThat(filter, notNullValue());
-        assertThat(filter.getDocCount(), equalTo(asc ? 2L : 3L));
-
-        tag = iters.next();
-        assertThat(tag, notNullValue());
-        assertThat(tag.getKeyAsString(), equalTo(asc ? "1" : "0"));
-        assertThat(tag.getDocCount(), equalTo(asc ? 3L : 2L));
-        filter = tag.getAggregations().get("filter");
-        assertThat(filter, notNullValue());
-        assertThat(filter.getDocCount(), equalTo(asc ? 3L : 2L));
+        assertNoFailuresAndResponse(
+            prepareSearch("idx").addAggregation(
+                new TermsAggregationBuilder("num_tags").field("num_tag")
+                    .collectMode(randomFrom(SubAggCollectionMode.values()))
+                    .order(BucketOrder.aggregation("filter", asc))
+                    .subAggregation(filter("filter", QueryBuilders.matchAllQuery()))
+            ),
+            response -> {
+                LongTerms tags = response.getAggregations().get("num_tags");
+                assertThat(tags, notNullValue());
+                assertThat(tags.getName(), equalTo("num_tags"));
+                assertThat(tags.getBuckets().size(), equalTo(2));
+
+                Iterator<LongTerms.Bucket> iters = tags.getBuckets().iterator();
+
+                LongTerms.Bucket tag = iters.next();
+                assertThat(tag, notNullValue());
+                assertThat(tag.getKeyAsString(), equalTo(asc ? "0" : "1"));
+                assertThat(tag.getDocCount(), equalTo(asc ? 2L : 3L));
+                Filter filter = tag.getAggregations().get("filter");
+                assertThat(filter, notNullValue());
+                assertThat(filter.getDocCount(), equalTo(asc ? 2L : 3L));
+
+                tag = iters.next();
+                assertThat(tag, notNullValue());
+                assertThat(tag.getKeyAsString(), equalTo(asc ? "1" : "0"));
+                assertThat(tag.getDocCount(), equalTo(asc ? 3L : 2L));
+                filter = tag.getAggregations().get("filter");
+                assertThat(filter, notNullValue());
+                assertThat(filter.getDocCount(), equalTo(asc ? 3L : 2L));
+            }
+        );
     }
 
     public void testSingleValuedFieldOrderedBySubAggregationAscMultiHierarchyLevels() throws Exception {
         boolean asc = randomBoolean();
-        SearchResponse response = prepareSearch("idx").addAggregation(
-            new TermsAggregationBuilder("tags").field("num_tag")
-                .collectMode(randomFrom(SubAggCollectionMode.values()))
-                .order(BucketOrder.aggregation("filter1>filter2>max", asc))
-                .subAggregation(
-                    filter("filter1", QueryBuilders.matchAllQuery()).subAggregation(
-                        filter("filter2", QueryBuilders.matchAllQuery()).subAggregation(max("max").field(SINGLE_VALUED_FIELD_NAME))
+        assertNoFailuresAndResponse(
+            prepareSearch("idx").addAggregation(
+                new TermsAggregationBuilder("tags").field("num_tag")
+                    .collectMode(randomFrom(SubAggCollectionMode.values()))
+                    .order(BucketOrder.aggregation("filter1>filter2>max", asc))
+                    .subAggregation(
+                        filter("filter1", QueryBuilders.matchAllQuery()).subAggregation(
+                            filter("filter2", QueryBuilders.matchAllQuery()).subAggregation(max("max").field(SINGLE_VALUED_FIELD_NAME))
+                        )
                     )
-                )
-        ).get();
-
-        assertNoFailures(response);
-
-        LongTerms tags = response.getAggregations().get("tags");
-        assertThat(tags, notNullValue());
-        assertThat(tags.getName(), equalTo("tags"));
-        assertThat(tags.getBuckets().size(), equalTo(2));
-
-        Iterator<LongTerms.Bucket> iters = tags.getBuckets().iterator();
-
-        // the max for "1" is 2
-        // the max for "0" is 4
-
-        LongTerms.Bucket tag = iters.next();
-        assertThat(tag, notNullValue());
-        assertThat(tag.getKeyAsString(), equalTo(asc ? "1" : "0"));
-        assertThat(tag.getDocCount(), equalTo(asc ? 3L : 2L));
-        Filter filter1 = tag.getAggregations().get("filter1");
-        assertThat(filter1, notNullValue());
-        assertThat(filter1.getDocCount(), equalTo(asc ? 3L : 2L));
-        Filter filter2 = filter1.getAggregations().get("filter2");
-        assertThat(filter2, notNullValue());
-        assertThat(filter2.getDocCount(), equalTo(asc ? 3L : 2L));
-        Max max = filter2.getAggregations().get("max");
-        assertThat(max, notNullValue());
-        assertThat(max.value(), equalTo(asc ? 2.0 : 4.0));
-
-        tag = iters.next();
-        assertThat(tag, notNullValue());
-        assertThat(tag.getKeyAsString(), equalTo(asc ? "0" : "1"));
-        assertThat(tag.getDocCount(), equalTo(asc ? 2L : 3L));
-        filter1 = tag.getAggregations().get("filter1");
-        assertThat(filter1, notNullValue());
-        assertThat(filter1.getDocCount(), equalTo(asc ? 2L : 3L));
-        filter2 = filter1.getAggregations().get("filter2");
-        assertThat(filter2, notNullValue());
-        assertThat(filter2.getDocCount(), equalTo(asc ? 2L : 3L));
-        max = filter2.getAggregations().get("max");
-        assertThat(max, notNullValue());
-        assertThat(max.value(), equalTo(asc ? 4.0 : 2.0));
+            ),
+            response -> {
+                LongTerms tags = response.getAggregations().get("tags");
+                assertThat(tags, notNullValue());
+                assertThat(tags.getName(), equalTo("tags"));
+                assertThat(tags.getBuckets().size(), equalTo(2));
+
+                Iterator<LongTerms.Bucket> iters = tags.getBuckets().iterator();
+
+                // the max for "1" is 2
+                // the max for "0" is 4
+
+                LongTerms.Bucket tag = iters.next();
+                assertThat(tag, notNullValue());
+                assertThat(tag.getKeyAsString(), equalTo(asc ? "1" : "0"));
+                assertThat(tag.getDocCount(), equalTo(asc ? 3L : 2L));
+                Filter filter1 = tag.getAggregations().get("filter1");
+                assertThat(filter1, notNullValue());
+                assertThat(filter1.getDocCount(), equalTo(asc ? 3L : 2L));
+                Filter filter2 = filter1.getAggregations().get("filter2");
+                assertThat(filter2, notNullValue());
+                assertThat(filter2.getDocCount(), equalTo(asc ? 3L : 2L));
+                Max max = filter2.getAggregations().get("max");
+                assertThat(max, notNullValue());
+                assertThat(max.value(), equalTo(asc ? 2.0 : 4.0));
+
+                tag = iters.next();
+                assertThat(tag, notNullValue());
+                assertThat(tag.getKeyAsString(), equalTo(asc ? "0" : "1"));
+                assertThat(tag.getDocCount(), equalTo(asc ? 2L : 3L));
+                filter1 = tag.getAggregations().get("filter1");
+                assertThat(filter1, notNullValue());
+                assertThat(filter1.getDocCount(), equalTo(asc ? 2L : 3L));
+                filter2 = filter1.getAggregations().get("filter2");
+                assertThat(filter2, notNullValue());
+                assertThat(filter2.getDocCount(), equalTo(asc ? 2L : 3L));
+                max = filter2.getAggregations().get("max");
+                assertThat(max, notNullValue());
+                assertThat(max.value(), equalTo(asc ? 4.0 : 2.0));
+            }
+        );
     }
 
     public void testSingleValuedFieldOrderedByMissingSubAggregation() throws Exception {
@@ -707,89 +725,89 @@ public class LongTermsIT extends AbstractTermsTestCase {
 
     public void testSingleValuedFieldOrderedByMultiValueSubAggregationAsc() throws Exception {
         boolean asc = true;
-        SearchResponse response = prepareSearch("idx").addAggregation(
-            new TermsAggregationBuilder("terms").field(SINGLE_VALUED_FIELD_NAME)
-                .collectMode(randomFrom(SubAggCollectionMode.values()))
-                .order(BucketOrder.aggregation("stats.avg", asc))
-                .subAggregation(stats("stats").field(SINGLE_VALUED_FIELD_NAME))
-        ).get();
-
-        assertNoFailures(response);
-
-        LongTerms terms = response.getAggregations().get("terms");
-        assertThat(terms, notNullValue());
-        assertThat(terms.getName(), equalTo("terms"));
-        assertThat(terms.getBuckets().size(), equalTo(5));
-
-        for (int i = 0; i < 5; i++) {
-            LongTerms.Bucket bucket = terms.getBucketByKey("" + i);
-            assertThat(bucket, notNullValue());
-            assertThat(bucket.getKeyAsString(), equalTo("" + i));
-            assertThat(bucket.getDocCount(), equalTo(1L));
-
-            Stats stats = bucket.getAggregations().get("stats");
-            assertThat(stats, notNullValue());
-            assertThat(stats.getMax(), equalTo((double) i));
-        }
-
+        assertNoFailuresAndResponse(
+            prepareSearch("idx").addAggregation(
+                new TermsAggregationBuilder("terms").field(SINGLE_VALUED_FIELD_NAME)
+                    .collectMode(randomFrom(SubAggCollectionMode.values()))
+                    .order(BucketOrder.aggregation("stats.avg", asc))
+                    .subAggregation(stats("stats").field(SINGLE_VALUED_FIELD_NAME))
+            ),
+            response -> {
+                LongTerms terms = response.getAggregations().get("terms");
+                assertThat(terms, notNullValue());
+                assertThat(terms.getName(), equalTo("terms"));
+                assertThat(terms.getBuckets().size(), equalTo(5));
+
+                for (int i = 0; i < 5; i++) {
+                    LongTerms.Bucket bucket = terms.getBucketByKey("" + i);
+                    assertThat(bucket, notNullValue());
+                    assertThat(bucket.getKeyAsString(), equalTo("" + i));
+                    assertThat(bucket.getDocCount(), equalTo(1L));
+
+                    Stats stats = bucket.getAggregations().get("stats");
+                    assertThat(stats, notNullValue());
+                    assertThat(stats.getMax(), equalTo((double) i));
+                }
+            }
+        );
     }
 
     public void testSingleValuedFieldOrderedByMultiValueSubAggregationDesc() throws Exception {
         boolean asc = false;
-        SearchResponse response = prepareSearch("idx").addAggregation(
-            new TermsAggregationBuilder("terms").field(SINGLE_VALUED_FIELD_NAME)
-                .collectMode(randomFrom(SubAggCollectionMode.values()))
-                .order(BucketOrder.aggregation("stats.avg", asc))
-                .subAggregation(stats("stats").field(SINGLE_VALUED_FIELD_NAME))
-        ).get();
-
-        assertNoFailures(response);
-
-        LongTerms terms = response.getAggregations().get("terms");
-        assertThat(terms, notNullValue());
-        assertThat(terms.getName(), equalTo("terms"));
-        assertThat(terms.getBuckets().size(), equalTo(5));
-
-        for (int i = 4; i >= 0; i--) {
-            LongTerms.Bucket bucket = terms.getBucketByKey("" + i);
-            assertThat(bucket, notNullValue());
-            assertThat(bucket.getKeyAsString(), equalTo("" + i));
-            assertThat(bucket.getDocCount(), equalTo(1L));
-
-            Stats stats = bucket.getAggregations().get("stats");
-            assertThat(stats, notNullValue());
-            assertThat(stats.getMax(), equalTo((double) i));
-        }
-
+        assertNoFailuresAndResponse(
+            prepareSearch("idx").addAggregation(
+                new TermsAggregationBuilder("terms").field(SINGLE_VALUED_FIELD_NAME)
+                    .collectMode(randomFrom(SubAggCollectionMode.values()))
+                    .order(BucketOrder.aggregation("stats.avg", asc))
+                    .subAggregation(stats("stats").field(SINGLE_VALUED_FIELD_NAME))
+            ),
+            response -> {
+                LongTerms terms = response.getAggregations().get("terms");
+                assertThat(terms, notNullValue());
+                assertThat(terms.getName(), equalTo("terms"));
+                assertThat(terms.getBuckets().size(), equalTo(5));
+
+                for (int i = 4; i >= 0; i--) {
+                    LongTerms.Bucket bucket = terms.getBucketByKey("" + i);
+                    assertThat(bucket, notNullValue());
+                    assertThat(bucket.getKeyAsString(), equalTo("" + i));
+                    assertThat(bucket.getDocCount(), equalTo(1L));
+
+                    Stats stats = bucket.getAggregations().get("stats");
+                    assertThat(stats, notNullValue());
+                    assertThat(stats.getMax(), equalTo((double) i));
+                }
+            }
+        );
     }
 
     public void testSingleValuedFieldOrderedByMultiValueExtendedStatsAsc() throws Exception {
         boolean asc = true;
-        SearchResponse response = prepareSearch("idx").addAggregation(
-            new TermsAggregationBuilder("terms").field(SINGLE_VALUED_FIELD_NAME)
-                .collectMode(randomFrom(SubAggCollectionMode.values()))
-                .order(BucketOrder.aggregation("stats.variance", asc))
-                .subAggregation(extendedStats("stats").field(SINGLE_VALUED_FIELD_NAME))
-        ).get();
-
-        assertNoFailures(response);
-
-        LongTerms terms = response.getAggregations().get("terms");
-        assertThat(terms, notNullValue());
-        assertThat(terms.getName(), equalTo("terms"));
-        assertThat(terms.getBuckets().size(), equalTo(5));
-
-        for (int i = 0; i < 5; i++) {
-            LongTerms.Bucket bucket = terms.getBucketByKey("" + i);
-            assertThat(bucket, notNullValue());
-            assertThat(bucket.getKeyAsString(), equalTo("" + i));
-            assertThat(bucket.getDocCount(), equalTo(1L));
-
-            ExtendedStats stats = bucket.getAggregations().get("stats");
-            assertThat(stats, notNullValue());
-            assertThat(stats.getMax(), equalTo((double) i));
-        }
-
+        assertNoFailuresAndResponse(
+            prepareSearch("idx").addAggregation(
+                new TermsAggregationBuilder("terms").field(SINGLE_VALUED_FIELD_NAME)
+                    .collectMode(randomFrom(SubAggCollectionMode.values()))
+                    .order(BucketOrder.aggregation("stats.variance", asc))
+                    .subAggregation(extendedStats("stats").field(SINGLE_VALUED_FIELD_NAME))
+            ),
+            response -> {
+                LongTerms terms = response.getAggregations().get("terms");
+                assertThat(terms, notNullValue());
+                assertThat(terms.getName(), equalTo("terms"));
+                assertThat(terms.getBuckets().size(), equalTo(5));
+
+                for (int i = 0; i < 5; i++) {
+                    LongTerms.Bucket bucket = terms.getBucketByKey("" + i);
+                    assertThat(bucket, notNullValue());
+                    assertThat(bucket.getKeyAsString(), equalTo("" + i));
+                    assertThat(bucket.getDocCount(), equalTo(1L));
+
+                    ExtendedStats stats = bucket.getAggregations().get("stats");
+                    assertThat(stats, notNullValue());
+                    assertThat(stats.getMax(), equalTo((double) i));
+                }
+            }
+        );
     }
 
     public void testSingleValuedFieldOrderedBySingleValueSubAggregationAscAndTermsDesc() throws Exception {
@@ -833,34 +851,35 @@ public class LongTermsIT extends AbstractTermsTestCase {
     }
 
     private void assertMultiSortResponse(long[] expectedKeys, BucketOrder... order) {
-        SearchResponse response = prepareSearch("sort_idx").addAggregation(
-            new TermsAggregationBuilder("terms").field(SINGLE_VALUED_FIELD_NAME)
-                .collectMode(randomFrom(SubAggCollectionMode.values()))
-                .order(BucketOrder.compound(order))
-                .subAggregation(avg("avg_l").field("l"))
-                .subAggregation(sum("sum_d").field("d"))
-        ).get();
-
-        assertNoFailures(response);
-
-        LongTerms terms = response.getAggregations().get("terms");
-        assertThat(terms, notNullValue());
-        assertThat(terms.getName(), equalTo("terms"));
-        assertThat(terms.getBuckets().size(), equalTo(expectedKeys.length));
-
-        int i = 0;
-        for (LongTerms.Bucket bucket : terms.getBuckets()) {
-            assertThat(bucket, notNullValue());
-            assertThat(bucket.getKeyAsString(), equalTo(String.valueOf(expectedKeys[i])));
-            assertThat(bucket.getDocCount(), equalTo(expectedMultiSortBuckets.get(expectedKeys[i]).get("_count")));
-            Avg avg = bucket.getAggregations().get("avg_l");
-            assertThat(avg, notNullValue());
-            assertThat(avg.getValue(), equalTo(expectedMultiSortBuckets.get(expectedKeys[i]).get("avg_l")));
-            Sum sum = bucket.getAggregations().get("sum_d");
-            assertThat(sum, notNullValue());
-            assertThat(sum.value(), equalTo(expectedMultiSortBuckets.get(expectedKeys[i]).get("sum_d")));
-            i++;
-        }
+        assertNoFailuresAndResponse(
+            prepareSearch("sort_idx").addAggregation(
+                new TermsAggregationBuilder("terms").field(SINGLE_VALUED_FIELD_NAME)
+                    .collectMode(randomFrom(SubAggCollectionMode.values()))
+                    .order(BucketOrder.compound(order))
+                    .subAggregation(avg("avg_l").field("l"))
+                    .subAggregation(sum("sum_d").field("d"))
+            ),
+            response -> {
+                LongTerms terms = response.getAggregations().get("terms");
+                assertThat(terms, notNullValue());
+                assertThat(terms.getName(), equalTo("terms"));
+                assertThat(terms.getBuckets().size(), equalTo(expectedKeys.length));
+
+                int i = 0;
+                for (LongTerms.Bucket bucket : terms.getBuckets()) {
+                    assertThat(bucket, notNullValue());
+                    assertThat(bucket.getKeyAsString(), equalTo(String.valueOf(expectedKeys[i])));
+                    assertThat(bucket.getDocCount(), equalTo(expectedMultiSortBuckets.get(expectedKeys[i]).get("_count")));
+                    Avg avg = bucket.getAggregations().get("avg_l");
+                    assertThat(avg, notNullValue());
+                    assertThat(avg.getValue(), equalTo(expectedMultiSortBuckets.get(expectedKeys[i]).get("avg_l")));
+                    Sum sum = bucket.getAggregations().get("sum_d");
+                    assertThat(sum, notNullValue());
+                    assertThat(sum.value(), equalTo(expectedMultiSortBuckets.get(expectedKeys[i]).get("sum_d")));
+                    i++;
+                }
+            }
+        );
     }
 
     public void testOtherDocCount() {
@@ -893,13 +912,13 @@ public class LongTermsIT extends AbstractTermsTestCase {
         );
 
         // Test that a request using a nondeterministic script does not get cached
-        SearchResponse r = prepareSearch("cache_test_idx").setSize(0)
-            .addAggregation(
-                new TermsAggregationBuilder("terms").field("d")
-                    .script(new Script(ScriptType.INLINE, CustomScriptPlugin.NAME, "Math.random()", Collections.emptyMap()))
-            )
-            .get();
-        assertNoFailures(r);
+        assertNoFailures(
+            prepareSearch("cache_test_idx").setSize(0)
+                .addAggregation(
+                    new TermsAggregationBuilder("terms").field("d")
+                        .script(new Script(ScriptType.INLINE, CustomScriptPlugin.NAME, "Math.random()", Collections.emptyMap()))
+                )
+        );
 
         assertThat(
             indicesAdmin().prepareStats("cache_test_idx").setRequestCache(true).get().getTotal().getRequestCache().getHitCount(),
@@ -911,13 +930,13 @@ public class LongTermsIT extends AbstractTermsTestCase {
         );
 
         // Test that a request using a deterministic script gets cached
-        r = prepareSearch("cache_test_idx").setSize(0)
-            .addAggregation(
-                new TermsAggregationBuilder("terms").field("d")
-                    .script(new Script(ScriptType.INLINE, CustomScriptPlugin.NAME, "_value + 1", Collections.emptyMap()))
-            )
-            .get();
-        assertNoFailures(r);
+        assertNoFailures(
+            prepareSearch("cache_test_idx").setSize(0)
+                .addAggregation(
+                    new TermsAggregationBuilder("terms").field("d")
+                        .script(new Script(ScriptType.INLINE, CustomScriptPlugin.NAME, "_value + 1", Collections.emptyMap()))
+                )
+        );
 
         assertThat(
             indicesAdmin().prepareStats("cache_test_idx").setRequestCache(true).get().getTotal().getRequestCache().getHitCount(),
@@ -929,8 +948,7 @@ public class LongTermsIT extends AbstractTermsTestCase {
         );
 
         // Ensure that non-scripted requests are cached as normal
-        r = prepareSearch("cache_test_idx").setSize(0).addAggregation(new TermsAggregationBuilder("terms").field("d")).get();
-        assertNoFailures(r);
+        assertNoFailures(prepareSearch("cache_test_idx").setSize(0).addAggregation(new TermsAggregationBuilder("terms").field("d")));
 
         assertThat(
             indicesAdmin().prepareStats("cache_test_idx").setRequestCache(true).get().getTotal().getRequestCache().getHitCount(),

server/src/internalClusterTest/java/org/elasticsearch/search/aggregations/bucket/MinDocCountIT.java

@@ -11,8 +11,6 @@ package org.elasticsearch.search.aggregations.bucket;
 import com.carrotsearch.randomizedtesting.generators.RandomStrings;
 
 import org.elasticsearch.action.index.IndexRequestBuilder;
-import org.elasticsearch.action.search.SearchRequest;
-import org.elasticsearch.action.search.SearchResponse;
 import org.elasticsearch.common.time.DateFormatter;
 import org.elasticsearch.index.fielddata.ScriptDocValues;
 import org.elasticsearch.index.query.QueryBuilder;
@@ -49,6 +47,7 @@ import static org.elasticsearch.search.aggregations.AggregationBuilders.histogra
 import static org.elasticsearch.search.aggregations.AggregationBuilders.terms;
 import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertAcked;
 import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertAllSuccessful;
+import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertResponse;
 import static org.elasticsearch.xcontent.XContentFactory.jsonBuilder;
 
 @ESIntegTestCase.SuiteScopeTestCase
@@ -306,41 +305,47 @@ public class MinDocCountIT extends AbstractTermsTestCase {
 
     private void testMinDocCountOnTerms(String field, Script script, BucketOrder order, String include, boolean retry) throws Exception {
         // all terms
-        final SearchResponse allTermsResponse = prepareSearch("idx").setSize(0)
-            .setQuery(QUERY)
-            .addAggregation(
-                script.apply(terms("terms"), field)
-                    .collectMode(randomFrom(SubAggCollectionMode.values()))
-                    .executionHint(randomExecutionHint())
-                    .order(order)
-                    .size(cardinality + randomInt(10))
-                    .minDocCount(0)
-            )
-            .get();
-        assertAllSuccessful(allTermsResponse);
-
-        final Terms allTerms = allTermsResponse.getAggregations().get("terms");
-        assertEquals(cardinality, allTerms.getBuckets().size());
-
-        for (long minDocCount = 0; minDocCount < 20; ++minDocCount) {
-            final int size = randomIntBetween(1, cardinality + 2);
-            final SearchRequest request = prepareSearch("idx").setSize(0)
+        assertResponse(
+            prepareSearch("idx").setSize(0)
                 .setQuery(QUERY)
                 .addAggregation(
                     script.apply(terms("terms"), field)
                         .collectMode(randomFrom(SubAggCollectionMode.values()))
                         .executionHint(randomExecutionHint())
                         .order(order)
-                        .size(size)
-                        .includeExclude(include == null ? null : new IncludeExclude(include, null, null, null))
-                        .shardSize(cardinality + randomInt(10))
-                        .minDocCount(minDocCount)
-                )
-                .request();
-            final SearchResponse response = client().search(request).get();
-            assertAllSuccessful(response);
-            assertSubset(allTerms, (Terms) response.getAggregations().get("terms"), minDocCount, size, include);
-        }
+                        .size(cardinality + randomInt(10))
+                        .minDocCount(0)
+                ),
+            allTermsResponse -> {
+                assertAllSuccessful(allTermsResponse);
+
+                final Terms allTerms = allTermsResponse.getAggregations().get("terms");
+                assertEquals(cardinality, allTerms.getBuckets().size());
+
+                for (long minDocCount = 0; minDocCount < 20; ++minDocCount) {
+                    final int size = randomIntBetween(1, cardinality + 2);
+                    final long finalMinDocCount = minDocCount;
+                    assertResponse(
+                        prepareSearch("idx").setSize(0)
+                            .setQuery(QUERY)
+                            .addAggregation(
+                                script.apply(terms("terms"), field)
+                                    .collectMode(randomFrom(SubAggCollectionMode.values()))
+                                    .executionHint(randomExecutionHint())
+                                    .order(order)
+                                    .size(size)
+                                    .includeExclude(include == null ? null : new IncludeExclude(include, null, null, null))
+                                    .shardSize(cardinality + randomInt(10))
+                                    .minDocCount(minDocCount)
+                            ),
+                        response -> {
+                            assertAllSuccessful(response);
+                            assertSubset(allTerms, (Terms) response.getAggregations().get("terms"), finalMinDocCount, size, include);
+                        }
+                    );
+                }
+            }
+        );
     }
 
     public void testHistogramCountAsc() throws Exception {
@@ -377,38 +382,52 @@ public class MinDocCountIT extends AbstractTermsTestCase {
 
     private void testMinDocCountOnHistogram(BucketOrder order) throws Exception {
         final int interval = randomIntBetween(1, 3);
-        final SearchResponse allResponse = prepareSearch("idx").setSize(0)
-            .setQuery(QUERY)
-            .addAggregation(histogram("histo").field("d").interval(interval).order(order).minDocCount(0))
-            .get();
-
-        final Histogram allHisto = allResponse.getAggregations().get("histo");
-
-        for (long minDocCount = 0; minDocCount < 50; ++minDocCount) {
-            final SearchResponse response = prepareSearch("idx").setSize(0)
+        assertResponse(
+            prepareSearch("idx").setSize(0)
                 .setQuery(QUERY)
-                .addAggregation(histogram("histo").field("d").interval(interval).order(order).minDocCount(minDocCount))
-                .get();
-            assertSubset(allHisto, (Histogram) response.getAggregations().get("histo"), minDocCount);
-        }
+                .addAggregation(histogram("histo").field("d").interval(interval).order(order).minDocCount(0)),
+            allResponse -> {
+                final Histogram allHisto = allResponse.getAggregations().get("histo");
+                for (long minDocCount = 0; minDocCount < 50; ++minDocCount) {
+                    final long finalMinDocCount = minDocCount;
+                    assertResponse(
+                        prepareSearch("idx").setSize(0)
+                            .setQuery(QUERY)
+                            .addAggregation(histogram("histo").field("d").interval(interval).order(order).minDocCount(minDocCount)),
+                        response -> {
+                            assertSubset(allHisto, response.getAggregations().get("histo"), finalMinDocCount);
+                        }
+                    );
+                }
+            }
+        );
     }
 
     private void testMinDocCountOnDateHistogram(BucketOrder order) throws Exception {
-        final SearchResponse allResponse = prepareSearch("idx").setSize(0)
-            .setQuery(QUERY)
-            .addAggregation(dateHistogram("histo").field("date").fixedInterval(DateHistogramInterval.DAY).order(order).minDocCount(0))
-            .get();
-
-        final Histogram allHisto = allResponse.getAggregations().get("histo");
-
-        for (long minDocCount = 0; minDocCount < 50; ++minDocCount) {
-            final SearchResponse response = prepareSearch("idx").setSize(0)
+        assertResponse(
+            prepareSearch("idx").setSize(0)
                 .setQuery(QUERY)
-                .addAggregation(
-                    dateHistogram("histo").field("date").fixedInterval(DateHistogramInterval.DAY).order(order).minDocCount(minDocCount)
-                )
-                .get();
-            assertSubset(allHisto, response.getAggregations().get("histo"), minDocCount);
-        }
+                .addAggregation(dateHistogram("histo").field("date").fixedInterval(DateHistogramInterval.DAY).order(order).minDocCount(0)),
+            allResponse -> {
+                final Histogram allHisto = allResponse.getAggregations().get("histo");
+
+                for (long minDocCount = 0; minDocCount < 50; ++minDocCount) {
+                    final long finalMinDocCount = minDocCount;
+                    assertResponse(
+                        prepareSearch("idx").setSize(0)
+                            .setQuery(QUERY)
+                            .addAggregation(
+                                dateHistogram("histo").field("date")
+                                    .fixedInterval(DateHistogramInterval.DAY)
+                                    .order(order)
+                                    .minDocCount(minDocCount)
+                            ),
+                        response -> {
+                            assertSubset(allHisto, response.getAggregations().get("histo"), finalMinDocCount);
+                        }
+                    );
+                }
+            }
+        );
     }
 }

server/src/internalClusterTest/java/org/elasticsearch/search/aggregations/bucket/NaNSortingIT.java

@@ -8,7 +8,6 @@
 
 package org.elasticsearch.search.aggregations.bucket;
 
-import org.elasticsearch.action.search.SearchResponse;
 import org.elasticsearch.common.util.Comparators;
 import org.elasticsearch.search.aggregations.Aggregation;
 import org.elasticsearch.search.aggregations.Aggregator.SubAggCollectionMode;
@@ -28,7 +27,7 @@ import static org.elasticsearch.search.aggregations.AggregationBuilders.extended
 import static org.elasticsearch.search.aggregations.AggregationBuilders.histogram;
 import static org.elasticsearch.search.aggregations.AggregationBuilders.terms;
 import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertAcked;
-import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertNoFailures;
+import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertNoFailuresAndResponse;
 import static org.elasticsearch.xcontent.XContentFactory.jsonBuilder;
 import static org.hamcrest.core.IsNull.notNullValue;
 
@@ -145,16 +144,18 @@ public class NaNSortingIT extends ESIntegTestCase {
     public void testTerms(String fieldName) {
         final boolean asc = randomBoolean();
         SubAggregation agg = randomFrom(SubAggregation.values());
-        SearchResponse response = prepareSearch("idx").addAggregation(
-            terms("terms").field(fieldName)
-                .collectMode(randomFrom(SubAggCollectionMode.values()))
-                .subAggregation(agg.builder())
-                .order(BucketOrder.aggregation(agg.sortKey(), asc))
-        ).get();
-
-        assertNoFailures(response);
-        final Terms terms = response.getAggregations().get("terms");
-        assertCorrectlySorted(terms, asc, agg);
+        assertNoFailuresAndResponse(
+            prepareSearch("idx").addAggregation(
+                terms("terms").field(fieldName)
+                    .collectMode(randomFrom(SubAggCollectionMode.values()))
+                    .subAggregation(agg.builder())
+                    .order(BucketOrder.aggregation(agg.sortKey(), asc))
+            ),
+            response -> {
+                final Terms terms = response.getAggregations().get("terms");
+                assertCorrectlySorted(terms, asc, agg);
+            }
+        );
     }
 
     public void testStringTerms() {
@@ -172,16 +173,17 @@ public class NaNSortingIT extends ESIntegTestCase {
     public void testLongHistogram() {
         final boolean asc = randomBoolean();
         SubAggregation agg = randomFrom(SubAggregation.values());
-        SearchResponse response = prepareSearch("idx").addAggregation(
-            histogram("histo").field("long_value")
-                .interval(randomIntBetween(1, 2))
-                .subAggregation(agg.builder())
-                .order(BucketOrder.aggregation(agg.sortKey(), asc))
-        ).get();
-
-        assertNoFailures(response);
-        final Histogram histo = response.getAggregations().get("histo");
-        assertCorrectlySorted(histo, asc, agg);
+        assertNoFailuresAndResponse(
+            prepareSearch("idx").addAggregation(
+                histogram("histo").field("long_value")
+                    .interval(randomIntBetween(1, 2))
+                    .subAggregation(agg.builder())
+                    .order(BucketOrder.aggregation(agg.sortKey(), asc))
+            ),
+            response -> {
+                final Histogram histo = response.getAggregations().get("histo");
+                assertCorrectlySorted(histo, asc, agg);
+            }
+        );
     }
-
 }

server/src/internalClusterTest/java/org/elasticsearch/search/aggregations/bucket/NestedIT.java

@@ -10,7 +10,6 @@ package org.elasticsearch.search.aggregations.bucket;
 import org.apache.lucene.search.join.ScoreMode;
 import org.elasticsearch.action.index.IndexRequestBuilder;
 import org.elasticsearch.action.search.SearchRequestBuilder;
-import org.elasticsearch.action.search.SearchResponse;
 import org.elasticsearch.index.query.InnerHitBuilder;
 import org.elasticsearch.rest.RestStatus;
 import org.elasticsearch.search.aggregations.Aggregator.SubAggCollectionMode;
@@ -47,7 +46,7 @@ import static org.elasticsearch.search.aggregations.AggregationBuilders.terms;
 import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertAcked;
 import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertFailures;
 import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertHitCount;
-import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertNoFailures;
+import static org.elasticsearch.test.hamcrest.ElasticsearchAssertions.assertNoFailuresAndResponse;
 import static org.elasticsearch.xcontent.XContentFactory.jsonBuilder;
 import static org.hamcrest.Matchers.containsString;
 import static org.hamcrest.Matchers.equalTo;
@@ -177,176 +176,186 @@ public class NestedIT extends ESIntegTestCase {
     }
 
     public void testSimple() throws Exception {
-        SearchResponse response = prepareSearch("idx").addAggregation(
-            nested("nested", "nested").subAggregation(stats("nested_value_stats").field("nested.value"))
-        ).get();
-
-        assertNoFailures(response);
+        assertNoFailuresAndResponse(
+            prepareSearch("idx").addAggregation(
+                nested("nested", "nested").subAggregation(stats("nested_value_stats").field("nested.value"))
+            ),
+            response -> {
+                double min = Double.POSITIVE_INFINITY;
+                double max = Double.NEGATIVE_INFINITY;
+                long sum = 0;
+                long count = 0;
+                for (int i = 0; i < numParents; ++i) {
+                    for (int j = 0; j < numChildren[i]; ++j) {
+                        final long value = i + 1 + j;
+                        min = Math.min(min, value);
+                        max = Math.max(max, value);
+                        sum += value;
+                        ++count;
+                    }
+                }
 
-        double min = Double.POSITIVE_INFINITY;
-        double max = Double.NEGATIVE_INFINITY;
-        long sum = 0;
-        long count = 0;
-        for (int i = 0; i < numParents; ++i) {
-            for (int j = 0; j < numChildren[i]; ++j) {
-                final long value = i + 1 + j;
-                min = Math.min(min, value);
-                max = Math.max(max, value);
-                sum += value;
-                ++count;
+                Nested nested = response.getAggregations().get("nested");
+                assertThat(nested, notNullValue());
+                assertThat(nested.getName(), equalTo("nested"));
+                assertThat(nested.getDocCount(), equalTo(count));
+                assertThat(nested.getAggregations().asList().isEmpty(), is(false));
+
+                Stats stats = nested.getAggregations().get("nested_value_stats");
+                assertThat(stats, notNullValue());
+                assertThat(stats.getMin(), equalTo(min));
+                assertThat(stats.getMax(), equalTo(max));
+                assertThat(stats.getCount(), equalTo(count));
+                assertThat(stats.getSum(), equalTo((double) sum));
+                assertThat(stats.getAvg(), equalTo((double) sum / count));
             }
-        }
-
-        Nested nested = response.getAggregations().get("nested");
-        assertThat(nested, notNullValue());
-        assertThat(nested.getName(), equalTo("nested"));
-        assertThat(nested.getDocCount(), equalTo(count));
-        assertThat(nested.getAggregations().asList().isEmpty(), is(false));
-
-        Stats stats = nested.getAggregations().get("nested_value_stats");
-        assertThat(stats, notNullValue());
-        assertThat(stats.getMin(), equalTo(min));
-        assertThat(stats.getMax(), equalTo(max));
-        assertThat(stats.getCount(), equalTo(count));
-        assertThat(stats.getSum(), equalTo((double) sum));
-        assertThat(stats.getAvg(), equalTo((double) sum / count));
+        );
     }
 
     public void testNonExistingNestedField() throws Exception {
-        SearchResponse searchResponse = prepareSearch("idx").addAggregation(
-            nested("nested", "value").subAggregation(stats("nested_value_stats").field("nested.value"))
-        ).get();
-
-        Nested nested = searchResponse.getAggregations().get("nested");
-        assertThat(nested, Matchers.notNullValue());
-        assertThat(nested.getName(), equalTo("nested"));
-        assertThat(nested.getDocCount(), is(0L));
+        assertNoFailuresAndResponse(
+            prepareSearch("idx").addAggregation(
+                nested("nested", "value").subAggregation(stats("nested_value_stats").field("nested.value"))
+            ),
+            response -> {
+                Nested nested = response.getAggregations().get("nested");
+                assertThat(nested, Matchers.notNullValue());
+                assertThat(nested.getName(), equalTo("nested"));
+                assertThat(nested.getDocCount(), is(0L));
+            }
+        );
     }
 
     public void testNestedWithSubTermsAgg() throws Exception {
-        SearchResponse response = prepareSearch("idx").addAggregation(
-            nested("nested", "nested").subAggregation(terms("values").field("nested.value").size(100).collectMode(aggCollectionMode))
-        ).get();
-
-        assertNoFailures(response);
-
-        long docCount = 0;
-        long[] counts = new long[numParents + 6];
-        for (int i = 0; i < numParents; ++i) {
-            for (int j = 0; j < numChildren[i]; ++j) {
-                final int value = i + 1 + j;
-                ++counts[value];
-                ++docCount;
-            }
-        }
-        int uniqueValues = 0;
-        for (long count : counts) {
-            if (count > 0) {
-                ++uniqueValues;
-            }
-        }
+        assertNoFailuresAndResponse(
+            prepareSearch("idx").addAggregation(
+                nested("nested", "nested").subAggregation(terms("values").field("nested.value").size(100).collectMode(aggCollectionMode))
+            ),
+            response -> {
+                long docCount = 0;
+                long[] counts = new long[numParents + 6];
+                for (int i = 0; i < numParents; ++i) {
+                    for (int j = 0; j < numChildren[i]; ++j) {
+                        final int value = i + 1 + j;
+                        ++counts[value];
+                        ++docCount;
+                    }
+                }
+                int uniqueValues = 0;
+                for (long count : counts) {
+                    if (count > 0) {
+                        ++uniqueValues;
+                    }
+                }
 
-        Nested nested = response.getAggregations().get("nested");
-        assertThat(nested, notNullValue());
-        assertThat(nested.getName(), equalTo("nested"));
-        assertThat(nested.getDocCount(), equalTo(docCount));
-        assertThat(((InternalAggregation) nested).getProperty("_count"), equalTo(docCount));
-        assertThat(nested.getAggregations().asList().isEmpty(), is(false));
-
-        LongTerms values = nested.getAggregations().get("values");
-        assertThat(values, notNullValue());
-        assertThat(values.getName(), equalTo("values"));
-        assertThat(values.getBuckets(), notNullValue());
-        assertThat(values.getBuckets().size(), equalTo(uniqueValues));
-        for (int i = 0; i < counts.length; ++i) {
-            final String key = Long.toString(i);
-            if (counts[i] == 0) {
-                assertNull(values.getBucketByKey(key));
-            } else {
-                Bucket bucket = values.getBucketByKey(key);
-                assertNotNull(bucket);
-                assertEquals(counts[i], bucket.getDocCount());
+                Nested nested = response.getAggregations().get("nested");
+                assertThat(nested, notNullValue());
+                assertThat(nested.getName(), equalTo("nested"));
+                assertThat(nested.getDocCount(), equalTo(docCount));
+                assertThat(((InternalAggregation) nested).getProperty("_count"), equalTo(docCount));
+                assertThat(nested.getAggregations().asList().isEmpty(), is(false));
+
+                LongTerms values = nested.getAggregations().get("values");
+                assertThat(values, notNullValue());
+                assertThat(values.getName(), equalTo("values"));
+                assertThat(values.getBuckets(), notNullValue());
+                assertThat(values.getBuckets().size(), equalTo(uniqueValues));
+                for (int i = 0; i < counts.length; ++i) {
+                    final String key = Long.toString(i);
+                    if (counts[i] == 0) {
+                        assertNull(values.getBucketByKey(key));
+                    } else {
+                        Bucket bucket = values.getBucketByKey(key);
+                        assertNotNull(bucket);
+                        assertEquals(counts[i], bucket.getDocCount());
+                    }
+                }
+                assertThat(((InternalAggregation) nested).getProperty("values"), sameInstance(values));
             }
-        }
-        assertThat(((InternalAggregation) nested).getProperty("values"), sameInstance(values));
+        );
     }
 
     public void testNestedAsSubAggregation() throws Exception {
-        SearchResponse response = prepareSearch("idx").addAggregation(
-            terms("top_values").field("value")
-                .size(100)
-                .collectMode(aggCollectionMode)
-                .subAggregation(nested("nested", "nested").subAggregation(max("max_value").field("nested.value")))
-        ).get();
-
-        assertNoFailures(response);
-
-        LongTerms values = response.getAggregations().get("top_values");
-        assertThat(values, notNullValue());
-        assertThat(values.getName(), equalTo("top_values"));
-        assertThat(values.getBuckets(), notNullValue());
-        assertThat(values.getBuckets().size(), equalTo(numParents));
-
-        for (int i = 0; i < numParents; i++) {
-            String topValue = "" + (i + 1);
-            assertThat(values.getBucketByKey(topValue), notNullValue());
-            Nested nested = values.getBucketByKey(topValue).getAggregations().get("nested");
-            assertThat(nested, notNullValue());
-            Max max = nested.getAggregations().get("max_value");
-            assertThat(max, notNullValue());
-            assertThat(max.value(), equalTo(numChildren[i] == 0 ? Double.NEGATIVE_INFINITY : (double) i + numChildren[i]));
-        }
+        assertNoFailuresAndResponse(
+            prepareSearch("idx").addAggregation(
+                terms("top_values").field("value")
+                    .size(100)
+                    .collectMode(aggCollectionMode)
+                    .subAggregation(nested("nested", "nested").subAggregation(max("max_value").field("nested.value")))
+            ),
+            response -> {
+                LongTerms values = response.getAggregations().get("top_values");
+                assertThat(values, notNullValue());
+                assertThat(values.getName(), equalTo("top_values"));
+                assertThat(values.getBuckets(), notNullValue());
+                assertThat(values.getBuckets().size(), equalTo(numParents));
+
+                for (int i = 0; i < numParents; i++) {
+                    String topValue = "" + (i + 1);
+                    assertThat(values.getBucketByKey(topValue), notNullValue());
+                    Nested nested = values.getBucketByKey(topValue).getAggregations().get("nested");
+                    assertThat(nested, notNullValue());
+                    Max max = nested.getAggregations().get("max_value");
+                    assertThat(max, notNullValue());
+                    assertThat(max.value(), equalTo(numChildren[i] == 0 ? Double.NEGATIVE_INFINITY : (double) i + numChildren[i]));
+                }
+            }
+        );
     }
 
     public void testNestNestedAggs() throws Exception {
-        SearchResponse response = prepareSearch("idx_nested_nested_aggs").addAggregation(
-            nested("level1", "nested1").subAggregation(
-                terms("a").field("nested1.a.keyword")
-                    .collectMode(aggCollectionMode)
-                    .subAggregation(nested("level2", "nested1.nested2").subAggregation(sum("sum").field("nested1.nested2.b")))
-            )
-        ).get();
-        assertNoFailures(response);
-
-        Nested level1 = response.getAggregations().get("level1");
-        assertThat(level1, notNullValue());
-        assertThat(level1.getName(), equalTo("level1"));
-        assertThat(level1.getDocCount(), equalTo(2L));
-
-        StringTerms a = level1.getAggregations().get("a");
-        Terms.Bucket bBucket = a.getBucketByKey("a");
-        assertThat(bBucket.getDocCount(), equalTo(1L));
-
-        Nested level2 = bBucket.getAggregations().get("level2");
-        assertThat(level2.getDocCount(), equalTo(1L));
-        Sum sum = level2.getAggregations().get("sum");
-        assertThat(sum.value(), equalTo(2d));
-
-        a = level1.getAggregations().get("a");
-        bBucket = a.getBucketByKey("b");
-        assertThat(bBucket.getDocCount(), equalTo(1L));
-
-        level2 = bBucket.getAggregations().get("level2");
-        assertThat(level2.getDocCount(), equalTo(1L));
-        sum = level2.getAggregations().get("sum");
-        assertThat(sum.value(), equalTo(2d));
+        assertNoFailuresAndResponse(
+            prepareSearch("idx_nested_nested_aggs").addAggregation(
+                nested("level1", "nested1").subAggregation(
+                    terms("a").field("nested1.a.keyword")
+                        .collectMode(aggCollectionMode)
+                        .subAggregation(nested("level2", "nested1.nested2").subAggregation(sum("sum").field("nested1.nested2.b")))
+                )
+            ),
+            response -> {
+                Nested level1 = response.getAggregations().get("level1");
+                assertThat(level1, notNullValue());
+                assertThat(level1.getName(), equalTo("level1"));
+                assertThat(level1.getDocCount(), equalTo(2L));
+
+                StringTerms a = level1.getAggregations().get("a");
+                Terms.Bucket bBucket = a.getBucketByKey("a");
+                assertThat(bBucket.getDocCount(), equalTo(1L));
+
+                Nested level2 = bBucket.getAggregations().get("level2");
+                assertThat(level2.getDocCount(), equalTo(1L));
+                Sum sum = level2.getAggregations().get("sum");
+                assertThat(sum.value(), equalTo(2d));
+
+                a = level1.getAggregations().get("a");
+                bBucket = a.getBucketByKey("b");
+                assertThat(bBucket.getDocCount(), equalTo(1L));
+
+                level2 = bBucket.getAggregations().get("level2");
+                assertThat(level2.getDocCount(), equalTo(1L));
+                sum = level2.getAggregations().get("sum");
+                assertThat(sum.value(), equalTo(2d));
+            }
+        );
     }
 
     public void testEmptyAggregation() throws Exception {
-        SearchResponse searchResponse = prepareSearch("empty_bucket_idx").setQuery(matchAllQuery())
-            .addAggregation(histogram("histo").field("value").interval(1L).minDocCount(0).subAggregation(nested("nested", "nested")))
-            .get();
-
-        assertThat(searchResponse.getHits().getTotalHits().value, equalTo(2L));
-        Histogram histo = searchResponse.getAggregations().get("histo");
-        assertThat(histo, Matchers.notNullValue());
-        Histogram.Bucket bucket = histo.getBuckets().get(1);
-        assertThat(bucket, Matchers.notNullValue());
-
-        Nested nested = bucket.getAggregations().get("nested");
-        assertThat(nested, Matchers.notNullValue());
-        assertThat(nested.getName(), equalTo("nested"));
-        assertThat(nested.getDocCount(), is(0L));
+        assertNoFailuresAndResponse(
+            prepareSearch("empty_bucket_idx").setQuery(matchAllQuery())
+                .addAggregation(histogram("histo").field("value").interval(1L).minDocCount(0).subAggregation(nested("nested", "nested"))),
+            response -> {
+                assertThat(response.getHits().getTotalHits().value, equalTo(2L));
+                Histogram histo = response.getAggregations().get("histo");
+                assertThat(histo, Matchers.notNullValue());
+                Histogram.Bucket bucket = histo.getBuckets().get(1);
+                assertThat(bucket, Matchers.notNullValue());
+
+                Nested nested = bucket.getAggregations().get("nested");
+                assertThat(nested, Matchers.notNullValue());
+                assertThat(nested.getName(), equalTo("nested"));
+                assertThat(nested.getDocCount(), is(0L));
+            }
+        );
     }
 
     // TODO previously we would detect if you tried to do a nested agg on a non-nested object field,
@@ -468,60 +477,65 @@ public class NestedIT extends ESIntegTestCase {
             }""", XContentType.JSON));
         indexRandom(true, indexRequests);
 
-        SearchResponse response = prepareSearch("idx2").addAggregation(
-            terms("startDate").field("dates.month.start")
-                .subAggregation(
-                    terms("endDate").field("dates.month.end")
-                        .subAggregation(
-                            terms("period").field("dates.month.label")
-                                .subAggregation(
-                                    nested("ctxt_idfier_nested", "comments").subAggregation(
-                                        filter("comment_filter", termQuery("comments.identifier", "29111")).subAggregation(
-                                            nested("nested_tags", "comments.tags").subAggregation(terms("tag").field("comments.tags.name"))
+        assertNoFailuresAndResponse(
+            prepareSearch("idx2").addAggregation(
+                terms("startDate").field("dates.month.start")
+                    .subAggregation(
+                        terms("endDate").field("dates.month.end")
+                            .subAggregation(
+                                terms("period").field("dates.month.label")
+                                    .subAggregation(
+                                        nested("ctxt_idfier_nested", "comments").subAggregation(
+                                            filter("comment_filter", termQuery("comments.identifier", "29111")).subAggregation(
+                                                nested("nested_tags", "comments.tags").subAggregation(
+                                                    terms("tag").field("comments.tags.name")
+                                                )
+                                            )
                                         )
                                     )
-                                )
-                        )
-                )
-        ).get();
-        assertNoFailures(response);
-        assertHitCount(response, 2);
-
-        Terms startDate = response.getAggregations().get("startDate");
-        assertThat(startDate.getBuckets().size(), equalTo(2));
-        Terms.Bucket bucket = startDate.getBucketByKey("2014-11-01T00:00:00.000Z");
-        assertThat(bucket.getDocCount(), equalTo(1L));
-        Terms endDate = bucket.getAggregations().get("endDate");
-        bucket = endDate.getBucketByKey("2014-11-30T00:00:00.000Z");
-        assertThat(bucket.getDocCount(), equalTo(1L));
-        Terms period = bucket.getAggregations().get("period");
-        bucket = period.getBucketByKey("2014-11");
-        assertThat(bucket.getDocCount(), equalTo(1L));
-        Nested comments = bucket.getAggregations().get("ctxt_idfier_nested");
-        assertThat(comments.getDocCount(), equalTo(2L));
-        Filter filter = comments.getAggregations().get("comment_filter");
-        assertThat(filter.getDocCount(), equalTo(1L));
-        Nested nestedTags = filter.getAggregations().get("nested_tags");
-        assertThat(nestedTags.getDocCount(), equalTo(0L)); // This must be 0
-        Terms tags = nestedTags.getAggregations().get("tag");
-        assertThat(tags.getBuckets().size(), equalTo(0)); // and this must be empty
-
-        bucket = startDate.getBucketByKey("2014-12-01T00:00:00.000Z");
-        assertThat(bucket.getDocCount(), equalTo(1L));
-        endDate = bucket.getAggregations().get("endDate");
-        bucket = endDate.getBucketByKey("2014-12-31T00:00:00.000Z");
-        assertThat(bucket.getDocCount(), equalTo(1L));
-        period = bucket.getAggregations().get("period");
-        bucket = period.getBucketByKey("2014-12");
-        assertThat(bucket.getDocCount(), equalTo(1L));
-        comments = bucket.getAggregations().get("ctxt_idfier_nested");
-        assertThat(comments.getDocCount(), equalTo(2L));
-        filter = comments.getAggregations().get("comment_filter");
-        assertThat(filter.getDocCount(), equalTo(1L));
-        nestedTags = filter.getAggregations().get("nested_tags");
-        assertThat(nestedTags.getDocCount(), equalTo(0L)); // This must be 0
-        tags = nestedTags.getAggregations().get("tag");
-        assertThat(tags.getBuckets().size(), equalTo(0)); // and this must be empty
+                            )
+                    )
+            ),
+            response -> {
+                assertHitCount(response, 2);
+
+                Terms startDate = response.getAggregations().get("startDate");
+                assertThat(startDate.getBuckets().size(), equalTo(2));
+                Terms.Bucket bucket = startDate.getBucketByKey("2014-11-01T00:00:00.000Z");
+                assertThat(bucket.getDocCount(), equalTo(1L));
+                Terms endDate = bucket.getAggregations().get("endDate");
+                bucket = endDate.getBucketByKey("2014-11-30T00:00:00.000Z");
+                assertThat(bucket.getDocCount(), equalTo(1L));
+                Terms period = bucket.getAggregations().get("period");
+                bucket = period.getBucketByKey("2014-11");
+                assertThat(bucket.getDocCount(), equalTo(1L));
+                Nested comments = bucket.getAggregations().get("ctxt_idfier_nested");
+                assertThat(comments.getDocCount(), equalTo(2L));
+                Filter filter = comments.getAggregations().get("comment_filter");
+                assertThat(filter.getDocCount(), equalTo(1L));
+                Nested nestedTags = filter.getAggregations().get("nested_tags");
+                assertThat(nestedTags.getDocCount(), equalTo(0L)); // This must be 0
+                Terms tags = nestedTags.getAggregations().get("tag");
+                assertThat(tags.getBuckets().size(), equalTo(0)); // and this must be empty
+
+                bucket = startDate.getBucketByKey("2014-12-01T00:00:00.000Z");
+                assertThat(bucket.getDocCount(), equalTo(1L));
+                endDate = bucket.getAggregations().get("endDate");
+                bucket = endDate.getBucketByKey("2014-12-31T00:00:00.000Z");
+                assertThat(bucket.getDocCount(), equalTo(1L));
+                period = bucket.getAggregations().get("period");
+                bucket = period.getBucketByKey("2014-12");
+                assertThat(bucket.getDocCount(), equalTo(1L));
+                comments = bucket.getAggregations().get("ctxt_idfier_nested");
+                assertThat(comments.getDocCount(), equalTo(2L));
+                filter = comments.getAggregations().get("comment_filter");
+                assertThat(filter.getDocCount(), equalTo(1L));
+                nestedTags = filter.getAggregations().get("nested_tags");
+                assertThat(nestedTags.getDocCount(), equalTo(0L)); // This must be 0
+                tags = nestedTags.getAggregations().get("tag");
+                assertThat(tags.getBuckets().size(), equalTo(0)); // and this must be empty
+            }
+        );
     }
 
     public void testNestedSameDocIdProcessedMultipleTime() throws Exception {
@@ -573,59 +587,62 @@ public class NestedIT extends ESIntegTestCase {
             .get();
         refresh();
 
-        SearchResponse response = prepareSearch("idx4").addAggregation(
-            terms("category").field("categories")
-                .subAggregation(nested("property", "property").subAggregation(terms("property_id").field("property.id")))
-        ).get();
-        assertNoFailures(response);
-        assertHitCount(response, 2);
-
-        Terms category = response.getAggregations().get("category");
-        assertThat(category.getBuckets().size(), equalTo(4));
-
-        Terms.Bucket bucket = category.getBucketByKey("1");
-        assertThat(bucket.getDocCount(), equalTo(2L));
-        Nested property = bucket.getAggregations().get("property");
-        assertThat(property.getDocCount(), equalTo(6L));
-        Terms propertyId = property.getAggregations().get("property_id");
-        assertThat(propertyId.getBuckets().size(), equalTo(5));
-        assertThat(propertyId.getBucketByKey("1").getDocCount(), equalTo(2L));
-        assertThat(propertyId.getBucketByKey("2").getDocCount(), equalTo(1L));
-        assertThat(propertyId.getBucketByKey("3").getDocCount(), equalTo(1L));
-        assertThat(propertyId.getBucketByKey("4").getDocCount(), equalTo(1L));
-        assertThat(propertyId.getBucketByKey("5").getDocCount(), equalTo(1L));
-
-        bucket = category.getBucketByKey("2");
-        assertThat(bucket.getDocCount(), equalTo(2L));
-        property = bucket.getAggregations().get("property");
-        assertThat(property.getDocCount(), equalTo(6L));
-        propertyId = property.getAggregations().get("property_id");
-        assertThat(propertyId.getBuckets().size(), equalTo(5));
-        assertThat(propertyId.getBucketByKey("1").getDocCount(), equalTo(2L));
-        assertThat(propertyId.getBucketByKey("2").getDocCount(), equalTo(1L));
-        assertThat(propertyId.getBucketByKey("3").getDocCount(), equalTo(1L));
-        assertThat(propertyId.getBucketByKey("4").getDocCount(), equalTo(1L));
-        assertThat(propertyId.getBucketByKey("5").getDocCount(), equalTo(1L));
-
-        bucket = category.getBucketByKey("3");
-        assertThat(bucket.getDocCount(), equalTo(1L));
-        property = bucket.getAggregations().get("property");
-        assertThat(property.getDocCount(), equalTo(3L));
-        propertyId = property.getAggregations().get("property_id");
-        assertThat(propertyId.getBuckets().size(), equalTo(3));
-        assertThat(propertyId.getBucketByKey("1").getDocCount(), equalTo(1L));
-        assertThat(propertyId.getBucketByKey("2").getDocCount(), equalTo(1L));
-        assertThat(propertyId.getBucketByKey("3").getDocCount(), equalTo(1L));
-
-        bucket = category.getBucketByKey("4");
-        assertThat(bucket.getDocCount(), equalTo(1L));
-        property = bucket.getAggregations().get("property");
-        assertThat(property.getDocCount(), equalTo(3L));
-        propertyId = property.getAggregations().get("property_id");
-        assertThat(propertyId.getBuckets().size(), equalTo(3));
-        assertThat(propertyId.getBucketByKey("1").getDocCount(), equalTo(1L));
-        assertThat(propertyId.getBucketByKey("2").getDocCount(), equalTo(1L));
-        assertThat(propertyId.getBucketByKey("3").getDocCount(), equalTo(1L));
+        assertNoFailuresAndResponse(
+            prepareSearch("idx4").addAggregation(
+                terms("category").field("categories")
+                    .subAggregation(nested("property", "property").subAggregation(terms("property_id").field("property.id")))
+            ),
+            response -> {
+                assertHitCount(response, 2);
+
+                Terms category = response.getAggregations().get("category");
+                assertThat(category.getBuckets().size(), equalTo(4));
+
+                Terms.Bucket bucket = category.getBucketByKey("1");
+                assertThat(bucket.getDocCount(), equalTo(2L));
+                Nested property = bucket.getAggregations().get("property");
+                assertThat(property.getDocCount(), equalTo(6L));
+                Terms propertyId = property.getAggregations().get("property_id");
+                assertThat(propertyId.getBuckets().size(), equalTo(5));
+                assertThat(propertyId.getBucketByKey("1").getDocCount(), equalTo(2L));
+                assertThat(propertyId.getBucketByKey("2").getDocCount(), equalTo(1L));
+                assertThat(propertyId.getBucketByKey("3").getDocCount(), equalTo(1L));
+                assertThat(propertyId.getBucketByKey("4").getDocCount(), equalTo(1L));
+                assertThat(propertyId.getBucketByKey("5").getDocCount(), equalTo(1L));
+
+                bucket = category.getBucketByKey("2");
+                assertThat(bucket.getDocCount(), equalTo(2L));
+                property = bucket.getAggregations().get("property");
+                assertThat(property.getDocCount(), equalTo(6L));
+                propertyId = property.getAggregations().get("property_id");
+                assertThat(propertyId.getBuckets().size(), equalTo(5));
+                assertThat(propertyId.getBucketByKey("1").getDocCount(), equalTo(2L));
+                assertThat(propertyId.getBucketByKey("2").getDocCount(), equalTo(1L));
+                assertThat(propertyId.getBucketByKey("3").getDocCount(), equalTo(1L));
+                assertThat(propertyId.getBucketByKey("4").getDocCount(), equalTo(1L));
+                assertThat(propertyId.getBucketByKey("5").getDocCount(), equalTo(1L));
+
+                bucket = category.getBucketByKey("3");
+                assertThat(bucket.getDocCount(), equalTo(1L));
+                property = bucket.getAggregations().get("property");
+                assertThat(property.getDocCount(), equalTo(3L));
+                propertyId = property.getAggregations().get("property_id");
+                assertThat(propertyId.getBuckets().size(), equalTo(3));
+                assertThat(propertyId.getBucketByKey("1").getDocCount(), equalTo(1L));
+                assertThat(propertyId.getBucketByKey("2").getDocCount(), equalTo(1L));
+                assertThat(propertyId.getBucketByKey("3").getDocCount(), equalTo(1L));
+
+                bucket = category.getBucketByKey("4");
+                assertThat(bucket.getDocCount(), equalTo(1L));
+                property = bucket.getAggregations().get("property");
+                assertThat(property.getDocCount(), equalTo(3L));
+                propertyId = property.getAggregations().get("property_id");
+                assertThat(propertyId.getBuckets().size(), equalTo(3));
+                assertThat(propertyId.getBucketByKey("1").getDocCount(), equalTo(1L));
+                assertThat(propertyId.getBucketByKey("2").getDocCount(), equalTo(1L));
+                assertThat(propertyId.getBucketByKey("3").getDocCount(), equalTo(1L));
+            }
+        );
     }
 
     public void testFilterAggInsideNestedAgg() throws Exception {
@@ -747,45 +764,52 @@ public class NestedIT extends ESIntegTestCase {
             .get();
         refresh();
 
-        SearchResponse response = prepareSearch("classes").addAggregation(
-            nested("to_method", "methods").subAggregation(
-                filter(
-                    "num_string_params",
-                    nestedQuery("methods.parameters", termQuery("methods.parameters.type", "String"), ScoreMode.None)
+        assertNoFailuresAndResponse(
+            prepareSearch("classes").addAggregation(
+                nested("to_method", "methods").subAggregation(
+                    filter(
+                        "num_string_params",
+                        nestedQuery("methods.parameters", termQuery("methods.parameters.type", "String"), ScoreMode.None)
+                    )
                 )
-            )
-        ).get();
-        Nested toMethods = response.getAggregations().get("to_method");
-        Filter numStringParams = toMethods.getAggregations().get("num_string_params");
-        assertThat(numStringParams.getDocCount(), equalTo(3L));
-
-        response = prepareSearch("classes").addAggregation(
-            nested("to_method", "methods").subAggregation(
-                terms("return_type").field("methods.return_type")
-                    .subAggregation(
-                        filter(
-                            "num_string_params",
-                            nestedQuery("methods.parameters", termQuery("methods.parameters.type", "String"), ScoreMode.None)
+            ),
+            response -> {
+                Nested toMethods = response.getAggregations().get("to_method");
+                Filter numStringParams = toMethods.getAggregations().get("num_string_params");
+                assertThat(numStringParams.getDocCount(), equalTo(3L));
+            }
+        );
+        assertNoFailuresAndResponse(
+            prepareSearch("classes").addAggregation(
+                nested("to_method", "methods").subAggregation(
+                    terms("return_type").field("methods.return_type")
+                        .subAggregation(
+                            filter(
+                                "num_string_params",
+                                nestedQuery("methods.parameters", termQuery("methods.parameters.type", "String"), ScoreMode.None)
+                            )
                         )
-                    )
-            )
-        ).get();
-        toMethods = response.getAggregations().get("to_method");
-        Terms terms = toMethods.getAggregations().get("return_type");
-        Bucket bucket = terms.getBucketByKey("void");
-        assertThat(bucket.getDocCount(), equalTo(3L));
-        numStringParams = bucket.getAggregations().get("num_string_params");
-        assertThat(numStringParams.getDocCount(), equalTo(2L));
-
-        bucket = terms.getBucketByKey("QueryBuilder");
-        assertThat(bucket.getDocCount(), equalTo(2L));
-        numStringParams = bucket.getAggregations().get("num_string_params");
-        assertThat(numStringParams.getDocCount(), equalTo(1L));
-
-        bucket = terms.getBucketByKey("Query");
-        assertThat(bucket.getDocCount(), equalTo(1L));
-        numStringParams = bucket.getAggregations().get("num_string_params");
-        assertThat(numStringParams.getDocCount(), equalTo(0L));
+                )
+            ),
+            response -> {
+                Nested toMethods = response.getAggregations().get("to_method");
+                Terms terms = toMethods.getAggregations().get("return_type");
+                Bucket bucket = terms.getBucketByKey("void");
+                assertThat(bucket.getDocCount(), equalTo(3L));
+                Filter numStringParams = bucket.getAggregations().get("num_string_params");
+                assertThat(numStringParams.getDocCount(), equalTo(2L));
+
+                bucket = terms.getBucketByKey("QueryBuilder");
+                assertThat(bucket.getDocCount(), equalTo(2L));
+                numStringParams = bucket.getAggregations().get("num_string_params");
+                assertThat(numStringParams.getDocCount(), equalTo(1L));
+
+                bucket = terms.getBucketByKey("Query");
+                assertThat(bucket.getDocCount(), equalTo(1L));
+                numStringParams = bucket.getAggregations().get("num_string_params");
+                assertThat(numStringParams.getDocCount(), equalTo(0L));
+            }
+        );
     }
 
     public void testExtractInnerHitBuildersWithDuplicateHitName() throws Exception {