Skip to content

Commit 2dd33db

Browse files
jpountzjpountz
committed
Add (failing) tests.
1 parent 615d2ee commit 2dd33db

File tree

2 files changed

+256
-21
lines changed

2 files changed

+256
-21
lines changed

‎src/test/java/org/elasticsearch/search/aggregations/metrics/AbstractNumericTests.java

Lines changed: 8 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -43,20 +43,27 @@ public Settings indexSettings() {
4343
.build();
4444
}
4545

46+
protected long minValue, maxValue, minValues, maxValues;
47+
4648
@Before
4749
public void init() throws Exception {
4850
createIndex("idx");
4951
createIndex("idx_unmapped");
5052

5153
List<IndexRequestBuilder> builders = new ArrayList<IndexRequestBuilder>();
5254

53-
for (int i = 0; i < 10; i++) { // TODO randomize the size and the params in here?
55+
final int numDocs = 10;
56+
for (int i = 0; i < numDocs; i++) { // TODO randomize the size and the params in here?
5457
builders.add(client().prepareIndex("idx", "type", ""+i).setSource(jsonBuilder()
5558
.startObject()
5659
.field("value", i+1)
5760
.startArray("values").value(i+2).value(i+3).endArray()
5861
.endObject()));
5962
}
63+
minValue = 1;
64+
minValues = 2;
65+
maxValue = numDocs;
66+
maxValues = numDocs + 2;
6067
indexRandom(true, builders);
6168

6269
// creating an index to test the empty buckets functionality. The way it works is by indexing

‎src/test/java/org/elasticsearch/search/aggregations/metrics/PercentilesTests.java

Lines changed: 248 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -20,11 +20,13 @@
2020
package org.elasticsearch.search.aggregations.metrics;
2121

2222
import org.elasticsearch.action.search.SearchResponse;
23+
import org.elasticsearch.common.logging.Loggers;
2324
import org.elasticsearch.search.aggregations.bucket.histogram.Histogram;
2425
import org.elasticsearch.search.aggregations.metrics.percentile.Percentiles;
25-
import org.junit.Ignore;
2626
import org.junit.Test;
2727

28+
import java.util.Arrays;
29+
2830
import static org.elasticsearch.index.query.QueryBuilders.matchAllQuery;
2931
import static org.elasticsearch.search.aggregations.AggregationBuilders.histogram;
3032
import static org.elasticsearch.search.aggregations.AggregationBuilders.percentiles;
@@ -36,15 +38,59 @@
3638
*/
3739
public class PercentilesTests extends AbstractNumericTests {
3840

39-
private Percentiles.ExecutionHint randomHint() {
40-
switch (randomInt(2)) {
41+
private static Percentiles.ExecutionHint randomHint() {
42+
final Percentiles.ExecutionHint executionHint = randomFrom(Arrays.asList(
43+
Percentiles.ExecutionHint.frugal()/*,
44+
Percentiles.ExecutionHint.qDigest(),
45+
Percentiles.ExecutionHint.tDigest()*/));
46+
Loggers.getLogger(PercentilesTests.class).info("Using execution_hint={}", executionHint);
47+
return executionHint;
48+
}
49+
50+
private static double[] randomPercentiles() {
51+
final int length = randomIntBetween(1, 20);
52+
final double[] percentiles = new double[length];
53+
for (int i = 0; i < percentiles.length; ++i) {
54+
switch (randomInt(20)) {
4155
case 0:
42-
return Percentiles.ExecutionHint.frugal();
56+
percentiles[i] = 0;
57+
break;
4358
case 1:
44-
return Percentiles.ExecutionHint.qDigest();
59+
percentiles[i] = 100;
60+
break;
4561
default:
46-
return Percentiles.ExecutionHint.tDigest();
62+
percentiles[i] = randomDouble() * 100;
63+
break;
64+
}
65+
}
66+
Loggers.getLogger(PercentilesTests.class).info("Using percentiles={}", Arrays.toString(percentiles));
67+
return percentiles;
68+
}
69+
70+
private void assertConsistent(double[] pcts, Percentiles percentiles, long minValue, long maxValue) {
71+
// TODO: check if any of these tests could pass with algos
72+
// it looks like it wouldn't be possible with frugal
73+
74+
/*assertNotNull(percentiles);
75+
final List<Percentile> percentileList = Lists.newArrayList(percentiles);
76+
CollectionUtil.introSort(percentileList, new Comparator<Percentile>() {
77+
@Override
78+
public int compare(Percentile o1, Percentile o2) {
79+
return Double.compare(o1.getPercent(), o2.getPercent());
80+
}
81+
});
82+
Arrays.sort(pcts);
83+
assertEquals(pcts.length, percentileList.size());
84+
for (int i = 0; i < pcts.length; ++i) {
85+
final Percentile percentile = percentileList.get(i);
86+
assertThat(percentile.getPercent(), equalTo(pcts[i]));
87+
assertThat(percentile.getValue(), greaterThanOrEqualTo((double) minValue));
88+
assertThat(percentile.getValue(), lessThanOrEqualTo((double) maxValue));
4789
}
90+
91+
for (int i = 1; i < percentileList.size(); ++i) {
92+
assertThat(percentileList.get(i).getValue(), greaterThanOrEqualTo(percentileList.get(i - 1).getValue()));
93+
}*/
4894
}
4995

5096
@Test
@@ -90,60 +136,242 @@ public void testUnmapped() throws Exception {
90136
assertThat(percentiles.percentile(15), equalTo(Double.NaN));
91137
}
92138

93-
@Test @Ignore
139+
@Test
94140
public void testSingleValuedField() throws Exception {
141+
final double[] pcts = randomPercentiles();
142+
SearchResponse searchResponse = client().prepareSearch("idx")
143+
.setQuery(matchAllQuery())
144+
.addAggregation(percentiles("percentiles")
145+
.field("value")
146+
.percentiles(pcts)
147+
.executionHint(randomHint()))
148+
.execute().actionGet();
149+
150+
assertThat(searchResponse.getHits().getTotalHits(), equalTo(10l));
151+
152+
final Percentiles percentiles = searchResponse.getAggregations().get("percentiles");
153+
assertConsistent(pcts, percentiles, minValue, maxValue);
95154
}
96155

97-
@Test @Ignore
156+
@Test
98157
public void testSingleValuedField_PartiallyUnmapped() throws Exception {
158+
final double[] pcts = randomPercentiles();
159+
SearchResponse searchResponse = client().prepareSearch("idx", "idx_unmapped")
160+
.setQuery(matchAllQuery())
161+
.addAggregation(percentiles("percentiles")
162+
.field("value")
163+
.percentiles(pcts)
164+
.executionHint(randomHint()))
165+
.execute().actionGet();
166+
167+
assertThat(searchResponse.getHits().getTotalHits(), equalTo(10l));
168+
169+
final Percentiles percentiles = searchResponse.getAggregations().get("percentiles");
170+
assertConsistent(pcts, percentiles, minValue, maxValue);
99171
}
100172

101-
@Test @Ignore
173+
@Test
102174
public void testSingleValuedField_WithValueScript() throws Exception {
175+
final double[] pcts = randomPercentiles();
176+
SearchResponse searchResponse = client().prepareSearch("idx")
177+
.setQuery(matchAllQuery())
178+
.addAggregation(percentiles("percentiles")
179+
.field("value").script("_value - 1")
180+
.percentiles(pcts)
181+
.executionHint(randomHint()))
182+
.execute().actionGet();
183+
184+
assertThat(searchResponse.getHits().getTotalHits(), equalTo(10l));
185+
186+
final Percentiles percentiles = searchResponse.getAggregations().get("percentiles");
187+
assertConsistent(pcts, percentiles, minValue - 1, maxValue - 1);
103188
}
104189

105-
@Test @Ignore
190+
@Test
106191
public void testSingleValuedField_WithValueScript_WithParams() throws Exception {
192+
final double[] pcts = randomPercentiles();
193+
SearchResponse searchResponse = client().prepareSearch("idx")
194+
.setQuery(matchAllQuery())
195+
.addAggregation(percentiles("percentiles")
196+
.field("value").script("_value - dec").param("dec", 1)
197+
.percentiles(pcts)
198+
.executionHint(randomHint()))
199+
.execute().actionGet();
200+
201+
assertThat(searchResponse.getHits().getTotalHits(), equalTo(10l));
202+
203+
final Percentiles percentiles = searchResponse.getAggregations().get("percentiles");
204+
assertConsistent(pcts, percentiles, minValue - 1, maxValue - 1);
107205
}
108206

109-
@Test @Ignore
207+
@Test
110208
public void testMultiValuedField() throws Exception {
209+
final double[] pcts = randomPercentiles();
210+
SearchResponse searchResponse = client().prepareSearch("idx")
211+
.setQuery(matchAllQuery())
212+
.addAggregation(percentiles("percentiles")
213+
.field("values")
214+
.percentiles(pcts)
215+
.executionHint(randomHint()))
216+
.execute().actionGet();
217+
218+
assertThat(searchResponse.getHits().getTotalHits(), equalTo(10l));
219+
220+
final Percentiles percentiles = searchResponse.getAggregations().get("percentiles");
221+
assertConsistent(pcts, percentiles, minValues, maxValues);
111222
}
112223

113-
@Test @Ignore
224+
@Test
114225
public void testMultiValuedField_WithValueScript() throws Exception {
226+
final double[] pcts = randomPercentiles();
227+
SearchResponse searchResponse = client().prepareSearch("idx")
228+
.setQuery(matchAllQuery())
229+
.addAggregation(percentiles("percentiles")
230+
.field("values").script("_value - 1")
231+
.percentiles(pcts)
232+
.executionHint(randomHint()))
233+
.execute().actionGet();
234+
235+
assertThat(searchResponse.getHits().getTotalHits(), equalTo(10l));
236+
237+
final Percentiles percentiles = searchResponse.getAggregations().get("percentiles");
238+
assertConsistent(pcts, percentiles, minValues - 1, maxValues - 1);
115239
}
116240

117-
@Test @Ignore
241+
@Test
118242
public void testMultiValuedField_WithValueScript_Reverse() throws Exception {
243+
final double[] pcts = randomPercentiles();
244+
SearchResponse searchResponse = client().prepareSearch("idx")
245+
.setQuery(matchAllQuery())
246+
.addAggregation(percentiles("percentiles")
247+
.field("values").script("_value * -1")
248+
.percentiles(pcts)
249+
.executionHint(randomHint()))
250+
.execute().actionGet();
251+
252+
assertThat(searchResponse.getHits().getTotalHits(), equalTo(10l));
253+
254+
final Percentiles percentiles = searchResponse.getAggregations().get("percentiles");
255+
assertConsistent(pcts, percentiles, -maxValues, -minValues);
119256
}
120257

121-
@Test @Ignore
258+
@Test
122259
public void testMultiValuedField_WithValueScript_WithParams() throws Exception {
260+
final double[] pcts = randomPercentiles();
261+
SearchResponse searchResponse = client().prepareSearch("idx")
262+
.setQuery(matchAllQuery())
263+
.addAggregation(percentiles("percentiles")
264+
.field("values").script("_value - dec").param("dec", 1)
265+
.percentiles(pcts)
266+
.executionHint(randomHint()))
267+
.execute().actionGet();
268+
269+
assertThat(searchResponse.getHits().getTotalHits(), equalTo(10l));
270+
271+
final Percentiles percentiles = searchResponse.getAggregations().get("percentiles");
272+
assertConsistent(pcts, percentiles, minValues - 1, maxValues - 1);
123273
}
124274

125-
@Test @Ignore
275+
@Test
126276
public void testScript_SingleValued() throws Exception {
277+
final double[] pcts = randomPercentiles();
278+
SearchResponse searchResponse = client().prepareSearch("idx")
279+
.setQuery(matchAllQuery())
280+
.addAggregation(percentiles("percentiles")
281+
.script("doc['value'].value")
282+
.percentiles(pcts)
283+
.executionHint(randomHint()))
284+
.execute().actionGet();
285+
286+
assertThat(searchResponse.getHits().getTotalHits(), equalTo(10l));
287+
288+
final Percentiles percentiles = searchResponse.getAggregations().get("percentiles");
289+
assertConsistent(pcts, percentiles, minValue, maxValue);
127290
}
128291

129-
@Test @Ignore
292+
@Test
130293
public void testScript_SingleValued_WithParams() throws Exception {
294+
final double[] pcts = randomPercentiles();
295+
SearchResponse searchResponse = client().prepareSearch("idx")
296+
.setQuery(matchAllQuery())
297+
.addAggregation(percentiles("percentiles")
298+
.script("doc['value'].value - dec").param("dec", 1)
299+
.percentiles(pcts)
300+
.executionHint(randomHint()))
301+
.execute().actionGet();
302+
303+
assertThat(searchResponse.getHits().getTotalHits(), equalTo(10l));
304+
305+
final Percentiles percentiles = searchResponse.getAggregations().get("percentiles");
306+
assertConsistent(pcts, percentiles, minValue - 1, maxValue - 1);
131307
}
132308

133-
@Test @Ignore
309+
@Test
134310
public void testScript_ExplicitSingleValued_WithParams() throws Exception {
311+
final double[] pcts = randomPercentiles();
312+
SearchResponse searchResponse = client().prepareSearch("idx")
313+
.setQuery(matchAllQuery())
314+
.addAggregation(percentiles("percentiles")
315+
.script("doc['value'].value - dec").param("dec", 1)
316+
.percentiles(pcts)
317+
.executionHint(randomHint()))
318+
.execute().actionGet();
319+
320+
assertThat(searchResponse.getHits().getTotalHits(), equalTo(10l));
321+
322+
final Percentiles percentiles = searchResponse.getAggregations().get("percentiles");
323+
assertConsistent(pcts, percentiles, minValue - 1, maxValue - 1);
135324
}
136325

137-
@Test @Ignore
326+
@Test
138327
public void testScript_MultiValued() throws Exception {
328+
final double[] pcts = randomPercentiles();
329+
SearchResponse searchResponse = client().prepareSearch("idx")
330+
.setQuery(matchAllQuery())
331+
.addAggregation(percentiles("percentiles")
332+
.script("doc['values'].values")
333+
.percentiles(pcts)
334+
.executionHint(randomHint()))
335+
.execute().actionGet();
336+
337+
assertThat(searchResponse.getHits().getTotalHits(), equalTo(10l));
338+
339+
final Percentiles percentiles = searchResponse.getAggregations().get("percentiles");
340+
assertConsistent(pcts, percentiles, minValues, maxValues);
139341
}
140342

141-
@Test @Ignore
343+
@Test
142344
public void testScript_ExplicitMultiValued() throws Exception {
345+
final double[] pcts = randomPercentiles();
346+
SearchResponse searchResponse = client().prepareSearch("idx")
347+
.setQuery(matchAllQuery())
348+
.addAggregation(percentiles("percentiles")
349+
.script("doc['values'].values")
350+
.percentiles(pcts)
351+
.executionHint(randomHint()))
352+
.execute().actionGet();
353+
354+
assertThat(searchResponse.getHits().getTotalHits(), equalTo(10l));
355+
356+
final Percentiles percentiles = searchResponse.getAggregations().get("percentiles");
357+
assertConsistent(pcts, percentiles, minValues, maxValues);
143358
}
144359

145-
@Test @Ignore
360+
@Test
146361
public void testScript_MultiValued_WithParams() throws Exception {
362+
final double[] pcts = randomPercentiles();
363+
SearchResponse searchResponse = client().prepareSearch("idx")
364+
.setQuery(matchAllQuery())
365+
.addAggregation(percentiles("percentiles")
366+
.script("List values = doc['values'].values; double[] res = new double[values.length]; for (int i = 0; i < res.length; i++) { res[i] = values.get(i) - dec; }; return res;").param("dec", 1)
367+
.percentiles(pcts)
368+
.executionHint(randomHint()))
369+
.execute().actionGet();
370+
371+
assertThat(searchResponse.getHits().getTotalHits(), equalTo(10l));
372+
373+
final Percentiles percentiles = searchResponse.getAggregations().get("percentiles");
374+
assertConsistent(pcts, percentiles, minValues - 1, maxValues - 1);
147375
}
148376

149377
}

0 commit comments

Comments
 (0)