public void ArithmeticPostAggregataionIsSet_SetsPostAggregationInBody()
{
var fields = new List <IPostAggregationSpec> {
new FieldAccessPostAggregator("loaded", "my_loaded"), new FieldAccessPostAggregator("total", "my_total")
};
var aggregations = new List <IPostAggregationSpec> {
new ArithmeticPostAggregator("average", ArithmeticFunction.Divide, fields)
};
var request = new TopNQueryDescriptor()
.PostAggregations(aggregations)
.Generate();
var agg = request.RequestData.PostAggregations.First() as ArithmeticPostAggregator;
Assert.IsNotNull(agg);
Assert.That(agg.Type, Is.EqualTo("arithmetic"));
Assert.That(agg.Name, Is.EqualTo("average"));
Assert.That(agg.Fn, Is.EqualTo("/"));
var field1 = agg.Fields.First() as FieldAccessPostAggregator;
Assert.IsNotNull(field1);
Assert.That(field1.Type, Is.EqualTo("fieldAccess"));
Assert.That(field1.Name, Is.EqualTo("loaded"));
Assert.That(field1.FieldName, Is.EqualTo("my_loaded"));
var field2 = agg.Fields.Last() as FieldAccessPostAggregator;
Assert.IsNotNull(field2);
Assert.That(field2.Type, Is.EqualTo("fieldAccess"));
Assert.That(field2.Name, Is.EqualTo("total"));
Assert.That(field2.FieldName, Is.EqualTo("my_total"));
}
public void ContextPropertiesAreSet_SetsContextInBody()
{
var request = new TopNQueryDescriptor()
.Context(
timeout: 60,
maxScatterGatherBytes: 100,
priority: 10,
queryId: "ABC",
useCache: false,
populateCache: false,
bySegment: true,
finalize: false,
chunkPeriod: "PT1H",
serializeDateTimeAsLong: true,
serializeDateTimeAsLongInner: false,
minTopNThreshold: 500
).Generate();
var context = request.RequestData.Context;
Assert.IsNotNull(context);
Assert.That(context.Timeout, Is.EqualTo(60));
Assert.That(context.MaxScatterGatherBytes, Is.EqualTo(100));
Assert.That(context.Priority, Is.EqualTo(10));
Assert.That(context.QueryId, Is.EqualTo("ABC"));
Assert.That(context.UseCache, Is.False);
Assert.That(context.PopulateCache, Is.False);
Assert.That(context.BySegment, Is.True);
Assert.That(context.Finalize, Is.False);
Assert.That(context.ChunkPeriod, Is.EqualTo("PT1H"));
Assert.That(context.SerializeDateTimeAsLong, Is.True);
Assert.That(context.SerializeDateTimeAsLongInner, Is.False);
Assert.That(context.MinTopNThreshold, Is.EqualTo(500));
}
public void ThresholdIsSet_SetsThresholdInBody()
{
var request = new TopNQueryDescriptor()
.Threshold(10)
.Generate();
Assert.That(request.RequestData.Threshold, Is.EqualTo(10));
}
public void GranularityIsSet_SetsGranularityInBody(Granularities granularity, string expectedGranularity)
{
var request = new TopNQueryDescriptor()
.Granularity(granularity)
.Generate();
Assert.That(request.RequestData.Granularity, Is.EqualTo(expectedGranularity));
}
public void DataSourceIsSet_SetsDataSourceInBody()
{
var request = new TopNQueryDescriptor()
.DataSource("test_datasource")
.Generate();
Assert.That(request.RequestData.DataSource, Is.EqualTo("test_datasource"));
}
public void DimensionIsSet_SetsDimensionInBody()
{
var request = new TopNQueryDescriptor()
.Dimension("test_dim")
.Generate();
Assert.That(request.RequestData.Dimension, Is.TypeOf <DefaultDimension>());
Assert.That(((DefaultDimension)request.RequestData.Dimension).Dimension, Is.EqualTo("test_dim"));
}
public void ToIntervalIsBeforeFromInterval_ToIntervalEqualsFromInterval()
{
var fromDate = DateTime.Parse("2017-10-01T14:45:22.123");
var toDate = fromDate.AddHours(-1);
var request = new TopNQueryDescriptor()
.Interval(fromDate, toDate)
.Generate();
Assert.That(request.RequestData.Intervals[0], Is.EqualTo("2017-10-01T14:45:22.123Z/2017-10-01T14:45:22.123Z"));
}
public void InvervalIsSet_SetsIntervalsInBody()
{
var fromDate = DateTime.Parse("2017-10-01T14:45:22.123");
var toDate = DateTime.Parse("2017-10-02T10:35:21.345");
var request = new TopNQueryDescriptor()
.Interval(fromDate, toDate)
.Generate();
Assert.That(request.RequestData.Intervals[0], Is.EqualTo("2017-10-01T14:45:22.123Z/2017-10-02T10:35:21.345Z"));
}
public void MetricIsSet_SetsMetricInBody()
{
var request = new TopNQueryDescriptor()
.Metric("test_metric")
.Generate();
var metric = request.RequestData.Metric as NumericTopNMetricSpec;
Assert.IsNotNull(metric);
Assert.That(metric.Type, Is.EqualTo("numeric"));
Assert.That(metric.Metric, Is.EqualTo("test_metric"));
}
public void MultipleInvervalsAreSet_SetsIntervalsInBody()
{
var fromDate = DateTime.Parse("2017-10-01T14:45:22.123");
var toDate = DateTime.Parse("2017-10-02T10:35:21.345");
var request = new TopNQueryDescriptor()
.Intervals(new Interval(fromDate, toDate), new Interval(fromDate.AddMonths(1), toDate.AddMonths(1)))
.Generate();
Assert.That(request.RequestData.Intervals.Count, Is.EqualTo(2));
Assert.That(request.RequestData.Intervals[0], Is.EqualTo("2017-10-01T14:45:22.123Z/2017-10-02T10:35:21.345Z"));
Assert.That(request.RequestData.Intervals[1], Is.EqualTo("2017-11-01T14:45:22.123Z/2017-11-02T10:35:21.345Z"));
}
public void SumAggregationIsSet_SetsAggregationInBody()
{
var request = new TopNQueryDescriptor()
.Aggregations(new LongSumAggregator("sum_count", "count"))
.Generate();
var agg = request.RequestData.Aggregations.First() as LongSumAggregator;
Assert.IsNotNull(agg);
Assert.That(agg.Type, Is.EqualTo("longSum"));
Assert.That(agg.Name, Is.EqualTo("sum_count"));
Assert.That(agg.FieldName, Is.EqualTo("count"));
}
public void BasicFilterIsSet_SetsFilterInBody()
{
var request = new TopNQueryDescriptor()
.Filter(new SelectorFilter("test_dim", "test_value"))
.Generate();
var filter = request.RequestData.Filter as SelectorFilter;
Assert.IsNotNull(filter);
Assert.That(filter.Type, Is.EqualTo("selector"));
Assert.That(filter.Dimension, Is.EqualTo("test_dim"));
Assert.That(filter.Value, Is.EqualTo("test_value"));
}
public void DurationGranularitySpecIsSet_SetsGranularityInBody()
{
var originDate = DateTime.Parse("2017-10-01T14:45:22");
var request = new TopNQueryDescriptor()
.Granularity(new DurationGranularity(60, originDate))
.Generate();
var granularity = request.RequestData.Granularity as DurationGranularity;
Assert.IsNotNull(granularity);
Assert.That(granularity.Type, Is.EqualTo("duration"));
Assert.That(granularity.Duration, Is.EqualTo(60));
Assert.That(granularity.Origin, Is.EqualTo(originDate));
}
public void PeriodGranularitySpecIsSet_SetsGranularityInBody()
{
var originDate = DateTime.Parse("2017-10-01T14:45:22");
var request = new TopNQueryDescriptor()
.Granularity(new PeriodGranularity("PT10M", "UTC", originDate))
.Generate();
var granularity = request.RequestData.Granularity as PeriodGranularity;
Assert.IsNotNull(granularity);
Assert.That(granularity.Type, Is.EqualTo("period"));
Assert.That(granularity.Period, Is.EqualTo("PT10M"));
Assert.That(granularity.TimeZone, Is.EqualTo("UTC"));
Assert.That(granularity.Origin, Is.EqualTo(originDate));
}
public void DefaultQuery_HasCorrectQueryType()
{
var request = new TopNQueryDescriptor().Generate();
Assert.That(request.RequestData.QueryType, Is.EqualTo("topN"));
}
