diff options
Diffstat (limited to 'core/src/test/java/org/elasticsearch/search/aggregations/metrics')
18 files changed, 456 insertions, 87 deletions
diff --git a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/InternalExtendedStatsTests.java b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/InternalExtendedStatsTests.java index 2e4f2e0587..8e90b88176 100644 --- a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/InternalExtendedStatsTests.java +++ b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/InternalExtendedStatsTests.java @@ -21,17 +21,19 @@ package org.elasticsearch.search.aggregations.metrics; import org.elasticsearch.common.io.stream.Writeable; import org.elasticsearch.search.DocValueFormat; +import org.elasticsearch.search.aggregations.ParsedAggregation; +import org.elasticsearch.search.aggregations.metrics.stats.extended.ExtendedStats.Bounds; import org.elasticsearch.search.aggregations.metrics.stats.extended.InternalExtendedStats; +import org.elasticsearch.search.aggregations.metrics.stats.extended.ParsedExtendedStats; import org.elasticsearch.search.aggregations.pipeline.PipelineAggregator; import org.elasticsearch.test.InternalAggregationTestCase; import org.junit.Before; -import java.util.Collections; import java.util.List; import java.util.Map; public class InternalExtendedStatsTests extends InternalAggregationTestCase<InternalExtendedStats> { - private double sigma; + protected double sigma; @Before public void randomSigma() { @@ -40,15 +42,19 @@ public class InternalExtendedStatsTests extends InternalAggregationTestCase<Inte @Override protected InternalExtendedStats createTestInstance(String name, List<PipelineAggregator> pipelineAggregators, - Map<String, Object> metaData) { - long count = randomIntBetween(1, 50); - double[] minMax = new double[2]; - minMax[0] = randomDouble(); - minMax[0] = randomDouble(); - double sum = randomDoubleBetween(0, 100, true); - return new InternalExtendedStats(name, count, sum, minMax[0], minMax[1], - randomDouble(), sigma, DocValueFormat.RAW, - pipelineAggregators, Collections.emptyMap()); + Map<String, Object> metaData) { + long count = frequently() ? randomIntBetween(1, Integer.MAX_VALUE) : 0; + double min = randomDoubleBetween(-1000000, 1000000, true); + double max = randomDoubleBetween(-1000000, 1000000, true); + double sum = randomDoubleBetween(-1000000, 1000000, true); + DocValueFormat format = randomNumericDocValueFormat(); + return createInstance(name, count, sum, min, max, randomDoubleBetween(0, 1000000, true), + sigma, format, pipelineAggregators, metaData); + } + + protected InternalExtendedStats createInstance(String name, long count, double sum, double min, double max, double sumOfSqrs, + double sigma, DocValueFormat formatter, List<PipelineAggregator> pipelineAggregators, Map<String, Object> metaData) { + return new InternalExtendedStats(name, count, sum, min, max, sumOfSqrs, sigma, formatter, pipelineAggregators, metaData); } @Override @@ -72,10 +78,33 @@ public class InternalExtendedStatsTests extends InternalAggregationTestCase<Inte } assertEquals(sigma, reduced.getSigma(), 0); assertEquals(expectedCount, reduced.getCount()); - assertEquals(expectedSum, reduced.getSum(), 1e-10); + assertEquals(expectedSum, reduced.getSum(), 1e-07); assertEquals(expectedMin, reduced.getMin(), 0d); assertEquals(expectedMax, reduced.getMax(), 0d); - assertEquals(expectedSumOfSquare, reduced.getSumOfSquares(), 1e-10); + assertEquals(expectedSumOfSquare, reduced.getSumOfSquares(), 1e-07); + } + + @Override + protected void assertFromXContent(InternalExtendedStats aggregation, ParsedAggregation parsedAggregation) { + assertTrue(parsedAggregation instanceof ParsedExtendedStats); + ParsedExtendedStats parsed = (ParsedExtendedStats) parsedAggregation; + InternalStatsTests.assertStats(aggregation, parsed); + + long count = aggregation.getCount(); + // for count == 0, fields are rendered as `null`, so we test that we parse to default values used also in the reduce phase + assertEquals(count > 0 ? aggregation.getSumOfSquares() : 0 , parsed.getSumOfSquares(), 0); + assertEquals(count > 0 ? aggregation.getVariance() : 0 , parsed.getVariance(), 0); + assertEquals(count > 0 ? aggregation.getStdDeviation() : 0 , parsed.getStdDeviation(), 0); + assertEquals(count > 0 ? aggregation.getStdDeviationBound(Bounds.LOWER) : 0 , parsed.getStdDeviationBound(Bounds.LOWER), 0); + assertEquals(count > 0 ? aggregation.getStdDeviationBound(Bounds.UPPER) : 0 , parsed.getStdDeviationBound(Bounds.UPPER), 0); + // also as_string values are only rendered for count != 0 + if (count > 0) { + assertEquals(aggregation.getSumOfSquaresAsString(), parsed.getSumOfSquaresAsString()); + assertEquals(aggregation.getVarianceAsString(), parsed.getVarianceAsString()); + assertEquals(aggregation.getStdDeviationAsString(), parsed.getStdDeviationAsString()); + assertEquals(aggregation.getStdDeviationBoundAsString(Bounds.LOWER), parsed.getStdDeviationBoundAsString(Bounds.LOWER)); + assertEquals(aggregation.getStdDeviationBoundAsString(Bounds.UPPER), parsed.getStdDeviationBoundAsString(Bounds.UPPER)); + } } @Override diff --git a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/InternalMaxTests.java b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/InternalMaxTests.java index f3b43d40a2..e2114fbebb 100644 --- a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/InternalMaxTests.java +++ b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/InternalMaxTests.java @@ -20,7 +20,10 @@ package org.elasticsearch.search.aggregations.metrics; import org.elasticsearch.common.io.stream.Writeable.Reader; +import org.elasticsearch.search.DocValueFormat; +import org.elasticsearch.search.aggregations.ParsedAggregation; import org.elasticsearch.search.aggregations.metrics.max.InternalMax; +import org.elasticsearch.search.aggregations.metrics.max.ParsedMax; import org.elasticsearch.search.aggregations.pipeline.PipelineAggregator; import org.elasticsearch.test.InternalAggregationTestCase; @@ -28,9 +31,12 @@ import java.util.List; import java.util.Map; public class InternalMaxTests extends InternalAggregationTestCase<InternalMax> { + @Override protected InternalMax createTestInstance(String name, List<PipelineAggregator> pipelineAggregators, Map<String, Object> metaData) { - return new InternalMax(name, randomDouble(), randomNumericDocValueFormat(), pipelineAggregators, metaData); + double value = frequently() ? randomDouble() : randomFrom(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY); + DocValueFormat formatter = randomNumericDocValueFormat(); + return new InternalMax(name, value, formatter, pipelineAggregators, metaData); } @Override @@ -42,4 +48,17 @@ public class InternalMaxTests extends InternalAggregationTestCase<InternalMax> { protected void assertReduced(InternalMax reduced, List<InternalMax> inputs) { assertEquals(inputs.stream().mapToDouble(InternalMax::value).max().getAsDouble(), reduced.value(), 0); } + + @Override + protected void assertFromXContent(InternalMax max, ParsedAggregation parsedAggregation) { + ParsedMax parsed = ((ParsedMax) parsedAggregation); + if (Double.isInfinite(max.getValue()) == false) { + assertEquals(max.getValue(), parsed.getValue(), Double.MIN_VALUE); + assertEquals(max.getValueAsString(), parsed.getValueAsString()); + } else { + // we write Double.NEGATIVE_INFINITY and Double.POSITIVE_INFINITY to xContent as 'null', so we + // cannot differentiate between them. Also we cannot recreate the exact String representation + assertEquals(parsed.getValue(), Double.NEGATIVE_INFINITY, 0); + } + } } diff --git a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/InternalStatsBucketTests.java b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/InternalStatsBucketTests.java new file mode 100644 index 0000000000..cbb097a728 --- /dev/null +++ b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/InternalStatsBucketTests.java @@ -0,0 +1,63 @@ +/* + * Licensed to Elasticsearch under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch licenses this file to you under + * the Apache License, Version 2.0 (the "License"); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.elasticsearch.search.aggregations.metrics; + +import org.elasticsearch.common.io.stream.Writeable; +import org.elasticsearch.search.DocValueFormat; +import org.elasticsearch.search.aggregations.ParsedAggregation; +import org.elasticsearch.search.aggregations.metrics.stats.InternalStats; +import org.elasticsearch.search.aggregations.pipeline.PipelineAggregator; +import org.elasticsearch.search.aggregations.pipeline.bucketmetrics.stats.InternalStatsBucket; +import org.elasticsearch.search.aggregations.pipeline.bucketmetrics.stats.ParsedStatsBucket; + +import java.util.Collections; +import java.util.List; +import java.util.Map; + +public class InternalStatsBucketTests extends InternalStatsTests { + + @Override + protected InternalStatsBucket createInstance(String name, long count, double sum, double min, double max, + DocValueFormat formatter, List<PipelineAggregator> pipelineAggregators, Map<String, Object> metaData) { + return new InternalStatsBucket(name, count, sum, min, max, formatter, pipelineAggregators, metaData); + } + + @Override + public void testReduceRandom() { + expectThrows(UnsupportedOperationException.class, + () -> createTestInstance("name", Collections.emptyList(), null).reduce(null, null)); + } + + @Override + protected void assertReduced(InternalStats reduced, List<InternalStats> inputs) { + // no test since reduce operation is unsupported + } + + @Override + protected Writeable.Reader<InternalStats> instanceReader() { + return InternalStatsBucket::new; + } + + @Override + protected void assertFromXContent(InternalStats aggregation, ParsedAggregation parsedAggregation) { + super.assertFromXContent(aggregation, parsedAggregation); + assertTrue(parsedAggregation instanceof ParsedStatsBucket); + } +} diff --git a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/InternalStatsTests.java b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/InternalStatsTests.java index c4da54ac6b..45bc4a8a9b 100644 --- a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/InternalStatsTests.java +++ b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/InternalStatsTests.java @@ -20,24 +20,30 @@ package org.elasticsearch.search.aggregations.metrics; import org.elasticsearch.common.io.stream.Writeable; import org.elasticsearch.search.DocValueFormat; +import org.elasticsearch.search.aggregations.ParsedAggregation; import org.elasticsearch.search.aggregations.metrics.stats.InternalStats; +import org.elasticsearch.search.aggregations.metrics.stats.ParsedStats; import org.elasticsearch.search.aggregations.pipeline.PipelineAggregator; import org.elasticsearch.test.InternalAggregationTestCase; -import java.util.Collections; import java.util.List; import java.util.Map; public class InternalStatsTests extends InternalAggregationTestCase<InternalStats> { + @Override - protected InternalStats createTestInstance(String name, List<PipelineAggregator> pipelineAggregators, - Map<String, Object> metaData) { + protected InternalStats createTestInstance(String name, List<PipelineAggregator> pipelineAggregators, Map<String, Object> metaData) { long count = frequently() ? randomIntBetween(1, Integer.MAX_VALUE) : 0; double min = randomDoubleBetween(-1000000, 1000000, true); double max = randomDoubleBetween(-1000000, 1000000, true); double sum = randomDoubleBetween(-1000000, 1000000, true); DocValueFormat format = randomNumericDocValueFormat(); - return new InternalStats(name, count, sum, min, max, format, pipelineAggregators, Collections.emptyMap()); + return createInstance(name, count, sum, min, max, format, pipelineAggregators, metaData); + } + + protected InternalStats createInstance(String name, long count, double sum, double min, double max, DocValueFormat formatter, + List<PipelineAggregator> pipelineAggregators, Map<String, Object> metaData) { + return new InternalStats(name, count, sum, min, max, formatter, pipelineAggregators, metaData); } @Override @@ -63,7 +69,32 @@ public class InternalStatsTests extends InternalAggregationTestCase<InternalStat } @Override + protected void assertFromXContent(InternalStats aggregation, ParsedAggregation parsedAggregation) { + assertTrue(parsedAggregation instanceof ParsedStats); + ParsedStats parsed = (ParsedStats) parsedAggregation; + assertStats(aggregation, parsed); + } + + static void assertStats(InternalStats aggregation, ParsedStats parsed) { + long count = aggregation.getCount(); + assertEquals(count, parsed.getCount()); + // for count == 0, fields are rendered as `null`, so we test that we parse to default values used also in the reduce phase + assertEquals(count > 0 ? aggregation.getMin() : Double.POSITIVE_INFINITY , parsed.getMin(), 0); + assertEquals(count > 0 ? aggregation.getMax() : Double.NEGATIVE_INFINITY, parsed.getMax(), 0); + assertEquals(count > 0 ? aggregation.getSum() : 0, parsed.getSum(), 0); + assertEquals(count > 0 ? aggregation.getAvg() : 0, parsed.getAvg(), 0); + // also as_string values are only rendered for count != 0 + if (count > 0) { + assertEquals(aggregation.getMinAsString(), parsed.getMinAsString()); + assertEquals(aggregation.getMaxAsString(), parsed.getMaxAsString()); + assertEquals(aggregation.getSumAsString(), parsed.getSumAsString()); + assertEquals(aggregation.getAvgAsString(), parsed.getAvgAsString()); + } + } + + @Override protected Writeable.Reader<InternalStats> instanceReader() { return InternalStats::new; } } + diff --git a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/avg/InternalAvgTests.java b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/avg/InternalAvgTests.java index ca902ae568..9cb248401d 100644 --- a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/avg/InternalAvgTests.java +++ b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/avg/InternalAvgTests.java @@ -20,6 +20,8 @@ package org.elasticsearch.search.aggregations.metrics.avg; import org.elasticsearch.common.io.stream.Writeable.Reader; +import org.elasticsearch.search.DocValueFormat; +import org.elasticsearch.search.aggregations.ParsedAggregation; import org.elasticsearch.search.aggregations.pipeline.PipelineAggregator; import org.elasticsearch.test.InternalAggregationTestCase; @@ -30,8 +32,9 @@ public class InternalAvgTests extends InternalAggregationTestCase<InternalAvg> { @Override protected InternalAvg createTestInstance(String name, List<PipelineAggregator> pipelineAggregators, Map<String, Object> metaData) { - return new InternalAvg(name, randomDoubleBetween(0, 100000, true), randomNonNegativeLong() % 100000, - randomNumericDocValueFormat(), pipelineAggregators, metaData); + DocValueFormat formatter = randomNumericDocValueFormat(); + long count = frequently() ? randomNonNegativeLong() % 100000 : 0; + return new InternalAvg(name, randomDoubleBetween(0, 100000, true), count, formatter, pipelineAggregators, metaData); } @Override @@ -51,4 +54,14 @@ public class InternalAvgTests extends InternalAggregationTestCase<InternalAvg> { assertEquals(sum, reduced.getSum(), 0.0000001); assertEquals(sum / counts, reduced.value(), 0.0000001); } + + @Override + protected void assertFromXContent(InternalAvg avg, ParsedAggregation parsedAggregation) { + ParsedAvg parsed = ((ParsedAvg) parsedAggregation); + assertEquals(avg.getValue(), parsed.getValue(), Double.MIN_VALUE); + // we don't print out VALUE_AS_STRING for avg.getCount() == 0, so we cannot get the exact same value back + if (avg.getCount() != 0) { + assertEquals(avg.getValueAsString(), parsed.getValueAsString()); + } + } } diff --git a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/cardinality/InternalCardinalityTests.java b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/cardinality/InternalCardinalityTests.java index 336def450a..1b46e0cdaf 100644 --- a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/cardinality/InternalCardinalityTests.java +++ b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/cardinality/InternalCardinalityTests.java @@ -24,10 +24,11 @@ import org.elasticsearch.common.lease.Releasables; import org.elasticsearch.common.settings.Settings; import org.elasticsearch.common.util.MockBigArrays; import org.elasticsearch.indices.breaker.NoneCircuitBreakerService; +import org.elasticsearch.test.InternalAggregationTestCase; +import org.elasticsearch.search.aggregations.ParsedAggregation; import org.elasticsearch.search.aggregations.pipeline.PipelineAggregator; import org.elasticsearch.test.InternalAggregationTestCase; import org.junit.After; -import org.junit.Before; import java.util.ArrayList; import java.util.List; @@ -37,12 +38,22 @@ public class InternalCardinalityTests extends InternalAggregationTestCase<Intern private static List<HyperLogLogPlusPlus> algos; private static int p; - @Before - public void setup() { + @Override + public void setUp() throws Exception { + super.setUp(); algos = new ArrayList<>(); p = randomIntBetween(HyperLogLogPlusPlus.MIN_PRECISION, HyperLogLogPlusPlus.MAX_PRECISION); } + @After //we force @After to have it run before ESTestCase#after otherwise it fails + @Override + public void tearDown() throws Exception { + super.tearDown(); + Releasables.close(algos); + algos.clear(); + algos = null; + } + @Override protected InternalCardinality createTestInstance(String name, List<PipelineAggregator> pipelineAggregators, Map<String, Object> metaData) { @@ -73,10 +84,12 @@ public class InternalCardinalityTests extends InternalAggregationTestCase<Intern } } - @After - public void cleanup() { - Releasables.close(algos); - algos.clear(); - algos = null; + @Override + protected void assertFromXContent(InternalCardinality aggregation, ParsedAggregation parsedAggregation) { + assertTrue(parsedAggregation instanceof ParsedCardinality); + ParsedCardinality parsed = (ParsedCardinality) parsedAggregation; + + assertEquals(aggregation.getValue(), parsed.getValue(), Double.MIN_VALUE); + assertEquals(aggregation.getValueAsString(), parsed.getValueAsString()); } } diff --git a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/geobounds/InternalGeoBoundsTests.java b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/geobounds/InternalGeoBoundsTests.java index 8ec1d924b5..133b948219 100644 --- a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/geobounds/InternalGeoBoundsTests.java +++ b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/geobounds/InternalGeoBoundsTests.java @@ -20,6 +20,7 @@ package org.elasticsearch.search.aggregations.metrics.geobounds; import org.elasticsearch.common.io.stream.Writeable; +import org.elasticsearch.search.aggregations.ParsedAggregation; import org.elasticsearch.search.aggregations.pipeline.PipelineAggregator; import org.elasticsearch.test.InternalAggregationTestCase; @@ -35,8 +36,10 @@ public class InternalGeoBoundsTests extends InternalAggregationTestCase<Internal @Override protected InternalGeoBounds createTestInstance(String name, List<PipelineAggregator> pipelineAggregators, Map<String, Object> metaData) { + // we occasionally want to test top = Double.NEGATIVE_INFINITY since this triggers empty xContent object + double top = frequently() ? randomDouble() : Double.NEGATIVE_INFINITY; InternalGeoBounds geo = new InternalGeoBounds(name, - randomDouble(), randomDouble(), randomDouble(), randomDouble(), + top, randomDouble(), randomDouble(), randomDouble(), randomDouble(), randomDouble(), randomBoolean(), pipelineAggregators, Collections.emptyMap()); return geo; @@ -70,12 +73,29 @@ public class InternalGeoBoundsTests extends InternalAggregationTestCase<Internal negRight = bounds.negRight; } } - assertThat(reduced.top, closeTo(top, GEOHASH_TOLERANCE)); - assertThat(reduced.bottom, closeTo(bottom, GEOHASH_TOLERANCE)); - assertThat(reduced.posLeft, closeTo(posLeft, GEOHASH_TOLERANCE)); - assertThat(reduced.posRight, closeTo(posRight, GEOHASH_TOLERANCE)); - assertThat(reduced.negLeft, closeTo(negLeft, GEOHASH_TOLERANCE)); - assertThat(reduced.negRight, closeTo(negRight, GEOHASH_TOLERANCE)); + assertValueClose(reduced.top, top); + assertValueClose(reduced.bottom, bottom); + assertValueClose(reduced.posLeft, posLeft); + assertValueClose(reduced.posRight, posRight); + assertValueClose(reduced.negLeft, negLeft); + assertValueClose(reduced.negRight, negRight); + } + + private static void assertValueClose(double expected, double actual) { + if (Double.isInfinite(expected) == false) { + assertThat(expected, closeTo(actual, GEOHASH_TOLERANCE)); + } else { + assertTrue(Double.isInfinite(actual)); + } + } + + @Override + protected void assertFromXContent(InternalGeoBounds aggregation, ParsedAggregation parsedAggregation) { + assertTrue(parsedAggregation instanceof ParsedGeoBounds); + ParsedGeoBounds parsed = (ParsedGeoBounds) parsedAggregation; + + assertEquals(aggregation.topLeft(), parsed.topLeft()); + assertEquals(aggregation.bottomRight(), parsed.bottomRight()); } @Override diff --git a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/geocentroid/InternalGeoCentroidTests.java b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/geocentroid/InternalGeoCentroidTests.java index d7c4328579..4e48649b07 100644 --- a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/geocentroid/InternalGeoCentroidTests.java +++ b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/geocentroid/InternalGeoCentroidTests.java @@ -21,6 +21,7 @@ package org.elasticsearch.search.aggregations.metrics.geocentroid; import org.apache.lucene.geo.GeoEncodingUtils; import org.elasticsearch.common.geo.GeoPoint; import org.elasticsearch.common.io.stream.Writeable; +import org.elasticsearch.search.aggregations.ParsedAggregation; import org.elasticsearch.search.aggregations.pipeline.PipelineAggregator; import org.elasticsearch.test.InternalAggregationTestCase; import org.elasticsearch.test.geo.RandomGeoGenerator; @@ -46,7 +47,7 @@ public class InternalGeoCentroidTests extends InternalAggregationTestCase<Intern if (count == 0) { centroid = null; } - return new InternalGeoCentroid("_name", centroid, count, Collections.emptyList(), Collections.emptyMap()); + return new InternalGeoCentroid(name, centroid, count, Collections.emptyList(), Collections.emptyMap()); } @Override @@ -70,4 +71,13 @@ public class InternalGeoCentroidTests extends InternalAggregationTestCase<Intern assertEquals(lonSum/totalCount, reduced.centroid().getLon(), 1E-5D); assertEquals(totalCount, reduced.count()); } + + @Override + protected void assertFromXContent(InternalGeoCentroid aggregation, ParsedAggregation parsedAggregation) { + assertTrue(parsedAggregation instanceof ParsedGeoCentroid); + ParsedGeoCentroid parsed = (ParsedGeoCentroid) parsedAggregation; + + assertEquals(aggregation.centroid(), parsed.centroid()); + assertEquals(aggregation.count(), parsed.count()); + } } diff --git a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/min/InternalMinTests.java b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/min/InternalMinTests.java index a40276e64c..f1cfa0a63b 100644 --- a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/min/InternalMinTests.java +++ b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/min/InternalMinTests.java @@ -20,6 +20,8 @@ package org.elasticsearch.search.aggregations.metrics.min; import org.elasticsearch.common.io.stream.Writeable.Reader; +import org.elasticsearch.search.DocValueFormat; +import org.elasticsearch.search.aggregations.ParsedAggregation; import org.elasticsearch.search.aggregations.pipeline.PipelineAggregator; import org.elasticsearch.test.InternalAggregationTestCase; @@ -29,7 +31,9 @@ import java.util.Map; public class InternalMinTests extends InternalAggregationTestCase<InternalMin> { @Override protected InternalMin createTestInstance(String name, List<PipelineAggregator> pipelineAggregators, Map<String, Object> metaData) { - return new InternalMin(name, randomDouble(), randomNumericDocValueFormat(), pipelineAggregators, metaData); + double value = frequently() ? randomDouble() : randomFrom(new Double[] { Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY }); + DocValueFormat formatter = randomNumericDocValueFormat(); + return new InternalMin(name, value, formatter, pipelineAggregators, metaData); } @Override @@ -41,4 +45,17 @@ public class InternalMinTests extends InternalAggregationTestCase<InternalMin> { protected void assertReduced(InternalMin reduced, List<InternalMin> inputs) { assertEquals(inputs.stream().mapToDouble(InternalMin::value).min().getAsDouble(), reduced.value(), 0); } + + @Override + protected void assertFromXContent(InternalMin min, ParsedAggregation parsedAggregation) { + ParsedMin parsed = ((ParsedMin) parsedAggregation); + if (Double.isInfinite(min.getValue()) == false) { + assertEquals(min.getValue(), parsed.getValue(), Double.MIN_VALUE); + assertEquals(min.getValueAsString(), parsed.getValueAsString()); + } else { + // we write Double.NEGATIVE_INFINITY and Double.POSITIVE_INFINITY to xContent as 'null', so we + // cannot differentiate between them. Also we cannot recreate the exact String representation + assertEquals(parsed.getValue(), Double.POSITIVE_INFINITY, 0); + } + } } diff --git a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/percentiles/AbstractPercentilesTestCase.java b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/percentiles/AbstractPercentilesTestCase.java new file mode 100644 index 0000000000..e7d808a9b3 --- /dev/null +++ b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/percentiles/AbstractPercentilesTestCase.java @@ -0,0 +1,85 @@ +/* + * Licensed to Elasticsearch under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch licenses this file to you under + * the Apache License, Version 2.0 (the "License"); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.elasticsearch.search.aggregations.metrics.percentiles; + +import org.elasticsearch.search.DocValueFormat; +import org.elasticsearch.search.aggregations.InternalAggregation; +import org.elasticsearch.search.aggregations.pipeline.PipelineAggregator; +import org.elasticsearch.test.InternalAggregationTestCase; + +import java.io.IOException; +import java.util.Arrays; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +public abstract class AbstractPercentilesTestCase<T extends InternalAggregation & Iterable<Percentile>> + extends InternalAggregationTestCase<T> { + + private double[] percents; + private boolean keyed; + private DocValueFormat docValueFormat; + + @Override + public void setUp() throws Exception { + super.setUp(); + percents = randomPercents(false); + keyed = randomBoolean(); + docValueFormat = randomNumericDocValueFormat(); + } + + @Override + protected T createTestInstance(String name, List<PipelineAggregator> pipelineAggregators, Map<String, Object> metaData) { + int numValues = randomInt(100); + double[] values = new double[numValues]; + for (int i = 0; i < numValues; ++i) { + values[i] = randomDouble(); + } + return createTestInstance(name, pipelineAggregators, metaData, keyed, docValueFormat, percents, values); + } + + protected abstract T createTestInstance(String name, List<PipelineAggregator> pipelineAggregators, Map<String, Object> metaData, + boolean keyed, DocValueFormat format, double[] percents, double[] values); + + protected abstract Class<? extends ParsedPercentiles> implementationClass(); + + public void testPercentilesIterators() throws IOException { + final T aggregation = createTestInstance(); + final Iterable<Percentile> parsedAggregation = parseAndAssert(aggregation, false); + + Iterator<Percentile> it = aggregation.iterator(); + Iterator<Percentile> parsedIt = parsedAggregation.iterator(); + while (it.hasNext()) { + assertEquals(it.next(), parsedIt.next()); + } + } + + public static double[] randomPercents(boolean sorted) { + List<Double> randomCdfValues = randomSubsetOf(randomIntBetween(1, 7), 0.01d, 0.05d, 0.25d, 0.50d, 0.75d, 0.95d, 0.99d); + double[] percents = new double[randomCdfValues.size()]; + for (int i = 0; i < randomCdfValues.size(); i++) { + percents[i] = randomCdfValues.get(i); + } + if (sorted) { + Arrays.sort(percents); + } + return percents; + } +} diff --git a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/percentiles/InternalPercentilesRanksTestCase.java b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/percentiles/InternalPercentilesRanksTestCase.java new file mode 100644 index 0000000000..f45b7cce51 --- /dev/null +++ b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/percentiles/InternalPercentilesRanksTestCase.java @@ -0,0 +1,42 @@ +/* + * Licensed to Elasticsearch under one or more contributor + * license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright + * ownership. Elasticsearch licenses this file to you under + * the Apache License, Version 2.0 (the "License"); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.elasticsearch.search.aggregations.metrics.percentiles; + +import org.elasticsearch.search.aggregations.InternalAggregation; +import org.elasticsearch.search.aggregations.ParsedAggregation; + +public abstract class InternalPercentilesRanksTestCase<T extends InternalAggregation & PercentileRanks> + extends AbstractPercentilesTestCase<T> { + + @Override + protected final void assertFromXContent(T aggregation, ParsedAggregation parsedAggregation) { + assertTrue(parsedAggregation instanceof PercentileRanks); + PercentileRanks parsedPercentileRanks = (PercentileRanks) parsedAggregation; + + for (Percentile percentile : aggregation) { + Double value = percentile.getValue(); + assertEquals(aggregation.percent(value), parsedPercentileRanks.percent(value), 0); + assertEquals(aggregation.percentAsString(value), parsedPercentileRanks.percentAsString(value)); + } + + Class<? extends ParsedPercentiles> parsedClass = implementationClass(); + assertTrue(parsedClass != null && parsedClass.isInstance(parsedAggregation)); + } +} diff --git a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/percentiles/InternalPercentilesTestCase.java b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/percentiles/InternalPercentilesTestCase.java index 52462fbdaf..8e06926ea0 100644 --- a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/percentiles/InternalPercentilesTestCase.java +++ b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/percentiles/InternalPercentilesTestCase.java @@ -19,36 +19,30 @@ package org.elasticsearch.search.aggregations.metrics.percentiles; -import org.elasticsearch.search.DocValueFormat; import org.elasticsearch.search.aggregations.InternalAggregation; +import org.elasticsearch.search.aggregations.ParsedAggregation; import org.elasticsearch.search.aggregations.pipeline.PipelineAggregator; import org.elasticsearch.test.InternalAggregationTestCase; import org.junit.Before; import java.util.List; -import java.util.Map; -public abstract class InternalPercentilesTestCase<T extends InternalAggregation> extends InternalAggregationTestCase<T> { - - private double[] percents; - - @Before - public void init() { - percents = randomPercents(); - } +public abstract class InternalPercentilesTestCase<T extends InternalAggregation & Percentiles> extends AbstractPercentilesTestCase<T> { @Override - protected T createTestInstance(String name, List<PipelineAggregator> pipelineAggregators, Map<String, Object> metaData) { - int numValues = randomInt(100); - double[] values = new double[numValues]; - for (int i = 0; i < numValues; ++i) { - values[i] = randomDouble(); + protected final void assertFromXContent(T aggregation, ParsedAggregation parsedAggregation) { + assertTrue(parsedAggregation instanceof Percentiles); + Percentiles parsedPercentiles = (Percentiles) parsedAggregation; + + for (Percentile percentile : aggregation) { + Double percent = percentile.getPercent(); + assertEquals(aggregation.percentile(percent), parsedPercentiles.percentile(percent), 0); + assertEquals(aggregation.percentileAsString(percent), parsedPercentiles.percentileAsString(percent)); } - return createTestInstance(name, pipelineAggregators, metaData, randomBoolean(), DocValueFormat.RAW, percents, values); - } - protected abstract T createTestInstance(String name, List<PipelineAggregator> pipelineAggregators, Map<String, Object> metaData, - boolean keyed, DocValueFormat format, double[] percents, double[] values); + Class<? extends ParsedPercentiles> parsedClass = implementationClass(); + assertTrue(parsedClass != null && parsedClass.isInstance(parsedAggregation)); + } public static double[] randomPercents() { List<Double> randomCdfValues = randomSubsetOf(randomIntBetween(1, 7), 0.01d, 0.05d, 0.25d, 0.50d, 0.75d, 0.95d, 0.99d); diff --git a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/percentiles/hdr/InternalHDRPercentilesRanksTests.java b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/percentiles/hdr/InternalHDRPercentilesRanksTests.java index e57e7ff116..728ddf6afa 100644 --- a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/percentiles/hdr/InternalHDRPercentilesRanksTests.java +++ b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/percentiles/hdr/InternalHDRPercentilesRanksTests.java @@ -22,27 +22,25 @@ package org.elasticsearch.search.aggregations.metrics.percentiles.hdr; import org.HdrHistogram.DoubleHistogram; import org.elasticsearch.common.io.stream.Writeable.Reader; import org.elasticsearch.search.DocValueFormat; +import org.elasticsearch.search.aggregations.metrics.percentiles.InternalPercentilesRanksTestCase; +import org.elasticsearch.search.aggregations.metrics.percentiles.ParsedPercentiles; import org.elasticsearch.search.aggregations.pipeline.PipelineAggregator; import org.elasticsearch.test.InternalAggregationTestCase; +import java.util.Arrays; import java.util.List; import java.util.Map; -public class InternalHDRPercentilesRanksTests extends InternalAggregationTestCase<InternalHDRPercentileRanks> { +public class InternalHDRPercentilesRanksTests extends InternalPercentilesRanksTestCase<InternalHDRPercentileRanks> { @Override - protected InternalHDRPercentileRanks createTestInstance(String name, List<PipelineAggregator> pipelineAggregators, - Map<String, Object> metaData) { - double[] cdfValues = new double[] { 0.5 }; - int numberOfSignificantValueDigits = 3; - DoubleHistogram state = new DoubleHistogram(numberOfSignificantValueDigits); - int numValues = randomInt(100); - for (int i = 0; i < numValues; ++i) { - state.recordValue(randomDouble()); - } - boolean keyed = false; - DocValueFormat format = DocValueFormat.RAW; - return new InternalHDRPercentileRanks(name, cdfValues, state, keyed, format, pipelineAggregators, metaData); + protected InternalHDRPercentileRanks createTestInstance(String name, List<PipelineAggregator> aggregators, Map<String, Object> metadata, + boolean keyed, DocValueFormat format, double[] percents, double[] values) { + + final DoubleHistogram state = new DoubleHistogram(3); + Arrays.stream(values).forEach(state::recordValue); + + return new InternalHDRPercentileRanks(name, percents, state, keyed, format, aggregators, metadata); } @Override @@ -60,4 +58,8 @@ public class InternalHDRPercentilesRanksTests extends InternalAggregationTestCas return InternalHDRPercentileRanks::new; } + @Override + protected Class<? extends ParsedPercentiles> implementationClass() { + return ParsedHDRPercentileRanks.class; + } } diff --git a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/percentiles/hdr/InternalHDRPercentilesTests.java b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/percentiles/hdr/InternalHDRPercentilesTests.java index 640f413734..07c74d78b0 100644 --- a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/percentiles/hdr/InternalHDRPercentilesTests.java +++ b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/percentiles/hdr/InternalHDRPercentilesTests.java @@ -23,6 +23,7 @@ import org.HdrHistogram.DoubleHistogram; import org.elasticsearch.common.io.stream.Writeable; import org.elasticsearch.search.DocValueFormat; import org.elasticsearch.search.aggregations.metrics.percentiles.InternalPercentilesTestCase; +import org.elasticsearch.search.aggregations.metrics.percentiles.ParsedPercentiles; import org.elasticsearch.search.aggregations.metrics.percentiles.Percentile; import org.elasticsearch.search.aggregations.pipeline.PipelineAggregator; @@ -63,8 +64,13 @@ public class InternalHDRPercentilesTests extends InternalPercentilesTestCase<Int return InternalHDRPercentiles::new; } + @Override + protected Class<? extends ParsedPercentiles> implementationClass() { + return ParsedHDRPercentiles.class; + } + public void testIterator() { - final double[] percents = randomPercents(); + final double[] percents = randomPercents(false); final double[] values = new double[frequently() ? randomIntBetween(1, 10) : 0]; for (int i = 0; i < values.length; ++i) { values[i] = randomDouble(); diff --git a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/percentiles/tdigest/InternalTDigestPercentilesRanksTests.java b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/percentiles/tdigest/InternalTDigestPercentilesRanksTests.java index c4bdf90728..f8698fda2c 100644 --- a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/percentiles/tdigest/InternalTDigestPercentilesRanksTests.java +++ b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/percentiles/tdigest/InternalTDigestPercentilesRanksTests.java @@ -21,26 +21,25 @@ package org.elasticsearch.search.aggregations.metrics.percentiles.tdigest; import org.elasticsearch.common.io.stream.Writeable.Reader; import org.elasticsearch.search.DocValueFormat; +import org.elasticsearch.search.aggregations.metrics.percentiles.InternalPercentilesRanksTestCase; +import org.elasticsearch.search.aggregations.metrics.percentiles.ParsedPercentiles; import org.elasticsearch.search.aggregations.pipeline.PipelineAggregator; -import org.elasticsearch.test.InternalAggregationTestCase; +import java.util.Arrays; import java.util.List; import java.util.Map; -public class InternalTDigestPercentilesRanksTests extends InternalAggregationTestCase<InternalTDigestPercentileRanks> { +public class InternalTDigestPercentilesRanksTests extends InternalPercentilesRanksTestCase<InternalTDigestPercentileRanks> { @Override - protected InternalTDigestPercentileRanks createTestInstance(String name, List<PipelineAggregator> pipelineAggregators, - Map<String, Object> metaData) { - double[] cdfValues = new double[] { 0.5 }; - TDigestState state = new TDigestState(100); - int numValues = randomInt(100); - for (int i = 0; i < numValues; ++i) { - state.add(randomDouble()); - } - boolean keyed = false; - DocValueFormat format = DocValueFormat.RAW; - return new InternalTDigestPercentileRanks(name, cdfValues, state, keyed, format, pipelineAggregators, metaData); + protected InternalTDigestPercentileRanks createTestInstance(String name, List<PipelineAggregator> aggregators, + Map<String, Object> metadata, + boolean keyed, DocValueFormat format, double[] percents, double[] values) { + final TDigestState state = new TDigestState(100); + Arrays.stream(values).forEach(state::add); + + assertEquals(state.centroidCount(), values.length); + return new InternalTDigestPercentileRanks(name, percents, state, keyed, format, aggregators, metadata); } @Override @@ -71,4 +70,8 @@ public class InternalTDigestPercentilesRanksTests extends InternalAggregationTes return InternalTDigestPercentileRanks::new; } + @Override + protected Class<? extends ParsedPercentiles> implementationClass() { + return ParsedTDigestPercentileRanks.class; + } } diff --git a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/percentiles/tdigest/InternalTDigestPercentilesTests.java b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/percentiles/tdigest/InternalTDigestPercentilesTests.java index f2db4a4853..867469592e 100644 --- a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/percentiles/tdigest/InternalTDigestPercentilesTests.java +++ b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/percentiles/tdigest/InternalTDigestPercentilesTests.java @@ -22,6 +22,7 @@ package org.elasticsearch.search.aggregations.metrics.percentiles.tdigest; import org.elasticsearch.common.io.stream.Writeable; import org.elasticsearch.search.DocValueFormat; import org.elasticsearch.search.aggregations.metrics.percentiles.InternalPercentilesTestCase; +import org.elasticsearch.search.aggregations.metrics.percentiles.ParsedPercentiles; import org.elasticsearch.search.aggregations.pipeline.PipelineAggregator; import java.util.Arrays; @@ -64,4 +65,9 @@ public class InternalTDigestPercentilesTests extends InternalPercentilesTestCase protected Writeable.Reader<InternalTDigestPercentiles> instanceReader() { return InternalTDigestPercentiles::new; } + + @Override + protected Class<? extends ParsedPercentiles> implementationClass() { + return ParsedTDigestPercentiles.class; + } } diff --git a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/sum/InternalSumTests.java b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/sum/InternalSumTests.java index cdaef89e42..1e5b8057cb 100644 --- a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/sum/InternalSumTests.java +++ b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/sum/InternalSumTests.java @@ -20,6 +20,7 @@ package org.elasticsearch.search.aggregations.metrics.sum; import org.elasticsearch.common.io.stream.Writeable; import org.elasticsearch.search.DocValueFormat; +import org.elasticsearch.search.aggregations.ParsedAggregation; import org.elasticsearch.search.aggregations.pipeline.PipelineAggregator; import org.elasticsearch.test.InternalAggregationTestCase; @@ -30,7 +31,9 @@ public class InternalSumTests extends InternalAggregationTestCase<InternalSum> { @Override protected InternalSum createTestInstance(String name, List<PipelineAggregator> pipelineAggregators, Map<String, Object> metaData) { - return new InternalSum(name, randomDouble(), DocValueFormat.RAW, pipelineAggregators, metaData); + double value = frequently() ? randomDouble() : randomFrom(new Double[] { Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY }); + DocValueFormat formatter = randomFrom(new DocValueFormat.Decimal("###.##"), DocValueFormat.BOOLEAN, DocValueFormat.RAW); + return new InternalSum(name, value, formatter, pipelineAggregators, metaData); } @Override @@ -43,4 +46,11 @@ public class InternalSumTests extends InternalAggregationTestCase<InternalSum> { double expectedSum = inputs.stream().mapToDouble(InternalSum::getValue).sum(); assertEquals(expectedSum, reduced.getValue(), 0.0001d); } + + @Override + protected void assertFromXContent(InternalSum sum, ParsedAggregation parsedAggregation) { + ParsedSum parsed = ((ParsedSum) parsedAggregation); + assertEquals(sum.getValue(), parsed.getValue(), Double.MIN_VALUE); + assertEquals(sum.getValueAsString(), parsed.getValueAsString()); + } } diff --git a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/valuecount/InternalValueCountTests.java b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/valuecount/InternalValueCountTests.java index e67d6fbf1d..e7483cad91 100644 --- a/core/src/test/java/org/elasticsearch/search/aggregations/metrics/valuecount/InternalValueCountTests.java +++ b/core/src/test/java/org/elasticsearch/search/aggregations/metrics/valuecount/InternalValueCountTests.java @@ -20,6 +20,7 @@ package org.elasticsearch.search.aggregations.metrics.valuecount; import org.elasticsearch.common.io.stream.Writeable; +import org.elasticsearch.search.aggregations.ParsedAggregation; import org.elasticsearch.search.aggregations.pipeline.PipelineAggregator; import org.elasticsearch.test.InternalAggregationTestCase; @@ -29,9 +30,8 @@ import java.util.Map; public class InternalValueCountTests extends InternalAggregationTestCase<InternalValueCount> { @Override - protected InternalValueCount createTestInstance(String name, - List<PipelineAggregator> pipelineAggregators, - Map<String, Object> metaData) { + protected InternalValueCount createTestInstance(String name, List<PipelineAggregator> pipelineAggregators, + Map<String, Object> metaData) { return new InternalValueCount(name, randomIntBetween(0, 100), pipelineAggregators, metaData); } @@ -44,4 +44,10 @@ public class InternalValueCountTests extends InternalAggregationTestCase<Interna protected Writeable.Reader<InternalValueCount> instanceReader() { return InternalValueCount::new; } + + @Override + protected void assertFromXContent(InternalValueCount valueCount, ParsedAggregation parsedAggregation) { + assertEquals(valueCount.getValue(), ((ParsedValueCount) parsedAggregation).getValue(), 0); + assertEquals(valueCount.getValueAsString(), ((ParsedValueCount) parsedAggregation).getValueAsString()); + } } |