mirror of
https://github.com/grafana/grafana.git
synced 2025-02-12 08:35:43 -06:00
baab021fec
Refactor usage of legacy data contracts. Moves legacy data contracts to pkg/tsdb/legacydata package. Refactor pkg/expr to be a proper service/dependency that can be provided to wire to remove some unneeded dependencies to SSE in ngalert and other places. Refactor pkg/expr to not use the legacydata,RequestHandler and use backend.QueryDataHandler instead.
409 lines
14 KiB
Go
409 lines
14 KiB
Go
package conditions
|
|
|
|
import (
|
|
"math"
|
|
"testing"
|
|
|
|
"github.com/grafana/grafana/pkg/components/null"
|
|
"github.com/grafana/grafana/pkg/tsdb/legacydata"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestSimpleReducer(t *testing.T) {
|
|
t.Run("sum", func(t *testing.T) {
|
|
result := testReducer("sum", 1, 2, 3)
|
|
require.Equal(t, float64(6), result)
|
|
})
|
|
|
|
t.Run("min", func(t *testing.T) {
|
|
result := testReducer("min", 3, 2, 1)
|
|
require.Equal(t, float64(1), result)
|
|
})
|
|
|
|
t.Run("max", func(t *testing.T) {
|
|
result := testReducer("max", 1, 2, 3)
|
|
require.Equal(t, float64(3), result)
|
|
})
|
|
|
|
t.Run("count", func(t *testing.T) {
|
|
result := testReducer("count", 1, 2, 3000)
|
|
require.Equal(t, float64(3), result)
|
|
})
|
|
|
|
t.Run("last", func(t *testing.T) {
|
|
result := testReducer("last", 1, 2, 3000)
|
|
require.Equal(t, float64(3000), result)
|
|
})
|
|
|
|
t.Run("median odd amount of numbers", func(t *testing.T) {
|
|
result := testReducer("median", 1, 2, 3000)
|
|
require.Equal(t, float64(2), result)
|
|
})
|
|
|
|
t.Run("median even amount of numbers", func(t *testing.T) {
|
|
result := testReducer("median", 1, 2, 4, 3000)
|
|
require.Equal(t, float64(3), result)
|
|
})
|
|
|
|
t.Run("median with one values", func(t *testing.T) {
|
|
result := testReducer("median", 1)
|
|
require.Equal(t, float64(1), result)
|
|
})
|
|
|
|
t.Run("median should ignore null values", func(t *testing.T) {
|
|
reducer := newSimpleReducer("median")
|
|
series := legacydata.DataTimeSeries{
|
|
Name: "test time series",
|
|
}
|
|
|
|
series.Points = append(series.Points, legacydata.DataTimePoint{null.FloatFromPtr(nil), null.FloatFrom(1)})
|
|
series.Points = append(series.Points, legacydata.DataTimePoint{null.FloatFromPtr(nil), null.FloatFrom(2)})
|
|
series.Points = append(series.Points, legacydata.DataTimePoint{null.FloatFromPtr(nil), null.FloatFrom(3)})
|
|
series.Points = append(series.Points, legacydata.DataTimePoint{null.FloatFrom(float64(1)), null.FloatFrom(4)})
|
|
series.Points = append(series.Points, legacydata.DataTimePoint{null.FloatFrom(float64(2)), null.FloatFrom(5)})
|
|
series.Points = append(series.Points, legacydata.DataTimePoint{null.FloatFrom(float64(3)), null.FloatFrom(6)})
|
|
|
|
result := reducer.Reduce(series)
|
|
require.Equal(t, true, result.Valid)
|
|
require.Equal(t, float64(2), result.Float64)
|
|
})
|
|
|
|
t.Run("avg", func(t *testing.T) {
|
|
result := testReducer("avg", 1, 2, 3)
|
|
require.Equal(t, float64(2), result)
|
|
})
|
|
|
|
t.Run("avg with only nulls", func(t *testing.T) {
|
|
reducer := newSimpleReducer("avg")
|
|
series := legacydata.DataTimeSeries{
|
|
Name: "test time series",
|
|
}
|
|
|
|
series.Points = append(series.Points, legacydata.DataTimePoint{null.FloatFromPtr(nil), null.FloatFrom(1)})
|
|
require.Equal(t, false, reducer.Reduce(series).Valid)
|
|
})
|
|
|
|
t.Run("count_non_null", func(t *testing.T) {
|
|
t.Run("with null values and real values", func(t *testing.T) {
|
|
reducer := newSimpleReducer("count_non_null")
|
|
series := legacydata.DataTimeSeries{
|
|
Name: "test time series",
|
|
}
|
|
|
|
series.Points = append(series.Points, legacydata.DataTimePoint{null.FloatFromPtr(nil), null.FloatFrom(1)})
|
|
series.Points = append(series.Points, legacydata.DataTimePoint{null.FloatFromPtr(nil), null.FloatFrom(2)})
|
|
series.Points = append(series.Points, legacydata.DataTimePoint{null.FloatFrom(3), null.FloatFrom(3)})
|
|
series.Points = append(series.Points, legacydata.DataTimePoint{null.FloatFrom(3), null.FloatFrom(4)})
|
|
|
|
require.Equal(t, true, reducer.Reduce(series).Valid)
|
|
require.Equal(t, 2.0, reducer.Reduce(series).Float64)
|
|
})
|
|
|
|
t.Run("with null values", func(t *testing.T) {
|
|
reducer := newSimpleReducer("count_non_null")
|
|
series := legacydata.DataTimeSeries{
|
|
Name: "test time series",
|
|
}
|
|
|
|
series.Points = append(series.Points, legacydata.DataTimePoint{null.FloatFromPtr(nil), null.FloatFrom(1)})
|
|
series.Points = append(series.Points, legacydata.DataTimePoint{null.FloatFromPtr(nil), null.FloatFrom(2)})
|
|
|
|
require.Equal(t, false, reducer.Reduce(series).Valid)
|
|
})
|
|
})
|
|
|
|
t.Run("avg of number values and null values should ignore nulls", func(t *testing.T) {
|
|
reducer := newSimpleReducer("avg")
|
|
series := legacydata.DataTimeSeries{
|
|
Name: "test time series",
|
|
}
|
|
|
|
series.Points = append(series.Points, legacydata.DataTimePoint{null.FloatFrom(3), null.FloatFrom(1)})
|
|
series.Points = append(series.Points, legacydata.DataTimePoint{null.FloatFromPtr(nil), null.FloatFrom(2)})
|
|
series.Points = append(series.Points, legacydata.DataTimePoint{null.FloatFromPtr(nil), null.FloatFrom(3)})
|
|
series.Points = append(series.Points, legacydata.DataTimePoint{null.FloatFrom(3), null.FloatFrom(4)})
|
|
|
|
require.Equal(t, float64(3), reducer.Reduce(series).Float64)
|
|
})
|
|
|
|
// diff function Test Suite
|
|
t.Run("diff of one positive point", func(t *testing.T) {
|
|
result := testReducer("diff", 30)
|
|
require.Equal(t, float64(0), result)
|
|
})
|
|
|
|
t.Run("diff of one negative point", func(t *testing.T) {
|
|
result := testReducer("diff", -30)
|
|
require.Equal(t, float64(0), result)
|
|
})
|
|
|
|
t.Run("diff of two positive points[1]", func(t *testing.T) {
|
|
result := testReducer("diff", 30, 40)
|
|
require.Equal(t, float64(10), result)
|
|
})
|
|
|
|
t.Run("diff of two positive points[2]", func(t *testing.T) {
|
|
result := testReducer("diff", 30, 20)
|
|
require.Equal(t, float64(-10), result)
|
|
})
|
|
|
|
t.Run("diff of two negative points[1]", func(t *testing.T) {
|
|
result := testReducer("diff", -30, -40)
|
|
require.Equal(t, float64(-10), result)
|
|
})
|
|
|
|
t.Run("diff of two negative points[2]", func(t *testing.T) {
|
|
result := testReducer("diff", -30, -10)
|
|
require.Equal(t, float64(20), result)
|
|
})
|
|
|
|
t.Run("diff of one positive and one negative point", func(t *testing.T) {
|
|
result := testReducer("diff", 30, -40)
|
|
require.Equal(t, float64(-70), result)
|
|
})
|
|
|
|
t.Run("diff of one negative and one positive point", func(t *testing.T) {
|
|
result := testReducer("diff", -30, 40)
|
|
require.Equal(t, float64(70), result)
|
|
})
|
|
|
|
t.Run("diff of three positive points", func(t *testing.T) {
|
|
result := testReducer("diff", 30, 40, 50)
|
|
require.Equal(t, float64(20), result)
|
|
})
|
|
|
|
t.Run("diff of three negative points", func(t *testing.T) {
|
|
result := testReducer("diff", -30, -40, -50)
|
|
require.Equal(t, float64(-20), result)
|
|
})
|
|
|
|
t.Run("diff with only nulls", func(t *testing.T) {
|
|
reducer := newSimpleReducer("diff")
|
|
series := legacydata.DataTimeSeries{
|
|
Name: "test time series",
|
|
}
|
|
|
|
series.Points = append(series.Points, legacydata.DataTimePoint{null.FloatFromPtr(nil), null.FloatFrom(1)})
|
|
series.Points = append(series.Points, legacydata.DataTimePoint{null.FloatFromPtr(nil), null.FloatFrom(2)})
|
|
|
|
require.Equal(t, false, reducer.Reduce(series).Valid)
|
|
})
|
|
|
|
// diff_abs function Test Suite
|
|
t.Run("diff_abs of one positive point", func(t *testing.T) {
|
|
result := testReducer("diff_abs", 30)
|
|
require.Equal(t, float64(0), result)
|
|
})
|
|
|
|
t.Run("diff_abs of one negative point", func(t *testing.T) {
|
|
result := testReducer("diff_abs", -30)
|
|
require.Equal(t, float64(0), result)
|
|
})
|
|
|
|
t.Run("diff_abs of two positive points[1]", func(t *testing.T) {
|
|
result := testReducer("diff_abs", 30, 40)
|
|
require.Equal(t, float64(10), result)
|
|
})
|
|
|
|
t.Run("diff_abs of two positive points[2]", func(t *testing.T) {
|
|
result := testReducer("diff_abs", 30, 20)
|
|
require.Equal(t, float64(10), result)
|
|
})
|
|
|
|
t.Run("diff_abs of two negative points[1]", func(t *testing.T) {
|
|
result := testReducer("diff_abs", -30, -40)
|
|
require.Equal(t, float64(10), result)
|
|
})
|
|
|
|
t.Run("diff_abs of two negative points[2]", func(t *testing.T) {
|
|
result := testReducer("diff_abs", -30, -10)
|
|
require.Equal(t, float64(20), result)
|
|
})
|
|
|
|
t.Run("diff_abs of one positive and one negative point", func(t *testing.T) {
|
|
result := testReducer("diff_abs", 30, -40)
|
|
require.Equal(t, float64(70), result)
|
|
})
|
|
|
|
t.Run("diff_abs of one negative and one positive point", func(t *testing.T) {
|
|
result := testReducer("diff_abs", -30, 40)
|
|
require.Equal(t, float64(70), result)
|
|
})
|
|
|
|
t.Run("diff_abs of three positive points", func(t *testing.T) {
|
|
result := testReducer("diff_abs", 30, 40, 50)
|
|
require.Equal(t, float64(20), result)
|
|
})
|
|
|
|
t.Run("diff_abs of three negative points", func(t *testing.T) {
|
|
result := testReducer("diff_abs", -30, -40, -50)
|
|
require.Equal(t, float64(20), result)
|
|
})
|
|
|
|
t.Run("diff_abs with only nulls", func(t *testing.T) {
|
|
reducer := newSimpleReducer("diff_abs")
|
|
series := legacydata.DataTimeSeries{
|
|
Name: "test time series",
|
|
}
|
|
|
|
series.Points = append(series.Points, legacydata.DataTimePoint{null.FloatFromPtr(nil), null.FloatFrom(1)})
|
|
series.Points = append(series.Points, legacydata.DataTimePoint{null.FloatFromPtr(nil), null.FloatFrom(2)})
|
|
|
|
require.Equal(t, false, reducer.Reduce(series).Valid)
|
|
})
|
|
|
|
// percent_diff function Test Suite
|
|
t.Run("percent_diff of one positive point", func(t *testing.T) {
|
|
result := testReducer("percent_diff", 30)
|
|
require.Equal(t, float64(0), result)
|
|
})
|
|
|
|
t.Run("percent_diff of one negative point", func(t *testing.T) {
|
|
result := testReducer("percent_diff", -30)
|
|
require.Equal(t, float64(0), result)
|
|
})
|
|
|
|
t.Run("percent_diff of two positive points[1]", func(t *testing.T) {
|
|
result := testReducer("percent_diff", 30, 40)
|
|
require.Equal(t, float64(33.33333333333333), result)
|
|
})
|
|
|
|
t.Run("percent_diff of two positive points[2]", func(t *testing.T) {
|
|
result := testReducer("percent_diff", 30, 20)
|
|
require.Equal(t, float64(-33.33333333333333), result)
|
|
})
|
|
|
|
t.Run("percent_diff of two negative points[1]", func(t *testing.T) {
|
|
result := testReducer("percent_diff", -30, -40)
|
|
require.Equal(t, float64(-33.33333333333333), result)
|
|
})
|
|
|
|
t.Run("percent_diff of two negative points[2]", func(t *testing.T) {
|
|
result := testReducer("percent_diff", -30, -10)
|
|
require.Equal(t, float64(66.66666666666666), result)
|
|
})
|
|
|
|
t.Run("percent_diff of one positive and one negative point", func(t *testing.T) {
|
|
result := testReducer("percent_diff", 30, -40)
|
|
require.Equal(t, float64(-233.33333333333334), result)
|
|
})
|
|
|
|
t.Run("percent_diff of one negative and one positive point", func(t *testing.T) {
|
|
result := testReducer("percent_diff", -30, 40)
|
|
require.Equal(t, float64(233.33333333333334), result)
|
|
})
|
|
|
|
t.Run("percent_diff of three positive points", func(t *testing.T) {
|
|
result := testReducer("percent_diff", 30, 40, 50)
|
|
require.Equal(t, float64(66.66666666666666), result)
|
|
})
|
|
|
|
t.Run("percent_diff of three negative points", func(t *testing.T) {
|
|
result := testReducer("percent_diff", -30, -40, -50)
|
|
require.Equal(t, float64(-66.66666666666666), result)
|
|
})
|
|
|
|
t.Run("percent_diff with only nulls", func(t *testing.T) {
|
|
reducer := newSimpleReducer("percent_diff")
|
|
series := legacydata.DataTimeSeries{
|
|
Name: "test time series",
|
|
}
|
|
|
|
series.Points = append(series.Points, legacydata.DataTimePoint{null.FloatFromPtr(nil), null.FloatFrom(1)})
|
|
series.Points = append(series.Points, legacydata.DataTimePoint{null.FloatFromPtr(nil), null.FloatFrom(2)})
|
|
|
|
require.Equal(t, false, reducer.Reduce(series).Valid)
|
|
})
|
|
|
|
// percent_diff_abs function Test Suite
|
|
t.Run("percent_diff_abs_abs of one positive point", func(t *testing.T) {
|
|
result := testReducer("percent_diff_abs", 30)
|
|
require.Equal(t, float64(0), result)
|
|
})
|
|
|
|
t.Run("percent_diff_abs of one negative point", func(t *testing.T) {
|
|
result := testReducer("percent_diff_abs", -30)
|
|
require.Equal(t, float64(0), result)
|
|
})
|
|
|
|
t.Run("percent_diff_abs of two positive points[1]", func(t *testing.T) {
|
|
result := testReducer("percent_diff_abs", 30, 40)
|
|
require.Equal(t, float64(33.33333333333333), result)
|
|
})
|
|
|
|
t.Run("percent_diff_abs of two positive points[2]", func(t *testing.T) {
|
|
result := testReducer("percent_diff_abs", 30, 20)
|
|
require.Equal(t, float64(33.33333333333333), result)
|
|
})
|
|
|
|
t.Run("percent_diff_abs of two negative points[1]", func(t *testing.T) {
|
|
result := testReducer("percent_diff_abs", -30, -40)
|
|
require.Equal(t, float64(33.33333333333333), result)
|
|
})
|
|
|
|
t.Run("percent_diff_abs of two negative points[2]", func(t *testing.T) {
|
|
result := testReducer("percent_diff_abs", -30, -10)
|
|
require.Equal(t, float64(66.66666666666666), result)
|
|
})
|
|
|
|
t.Run("percent_diff_abs of one positive and one negative point", func(t *testing.T) {
|
|
result := testReducer("percent_diff_abs", 30, -40)
|
|
require.Equal(t, float64(233.33333333333334), result)
|
|
})
|
|
|
|
t.Run("percent_diff_abs of one negative and one positive point", func(t *testing.T) {
|
|
result := testReducer("percent_diff_abs", -30, 40)
|
|
require.Equal(t, float64(233.33333333333334), result)
|
|
})
|
|
|
|
t.Run("percent_diff_abs of three positive points", func(t *testing.T) {
|
|
result := testReducer("percent_diff_abs", 30, 40, 50)
|
|
require.Equal(t, float64(66.66666666666666), result)
|
|
})
|
|
|
|
t.Run("percent_diff_abs of three negative points", func(t *testing.T) {
|
|
result := testReducer("percent_diff_abs", -30, -40, -50)
|
|
require.Equal(t, float64(66.66666666666666), result)
|
|
})
|
|
|
|
t.Run("percent_diff_abs with only nulls", func(t *testing.T) {
|
|
reducer := newSimpleReducer("percent_diff_abs")
|
|
series := legacydata.DataTimeSeries{
|
|
Name: "test time series",
|
|
}
|
|
|
|
series.Points = append(series.Points, legacydata.DataTimePoint{null.FloatFromPtr(nil), null.FloatFrom(1)})
|
|
series.Points = append(series.Points, legacydata.DataTimePoint{null.FloatFromPtr(nil), null.FloatFrom(2)})
|
|
|
|
require.Equal(t, false, reducer.Reduce(series).Valid)
|
|
})
|
|
|
|
t.Run("min should work with NaNs", func(t *testing.T) {
|
|
result := testReducer("min", math.NaN(), math.NaN(), math.NaN())
|
|
require.Equal(t, float64(0), result)
|
|
})
|
|
|
|
t.Run("isValid should treat NaN as invalid", func(t *testing.T) {
|
|
result := isValid(null.FloatFrom(math.NaN()))
|
|
require.False(t, result)
|
|
})
|
|
|
|
t.Run("isValid should treat invalid null.Float as invalid", func(t *testing.T) {
|
|
result := isValid(null.FloatFromPtr(nil))
|
|
require.False(t, result)
|
|
})
|
|
}
|
|
|
|
func testReducer(reducerType string, datapoints ...float64) float64 {
|
|
reducer := newSimpleReducer(reducerType)
|
|
series := legacydata.DataTimeSeries{
|
|
Name: "test time series",
|
|
}
|
|
|
|
for idx := range datapoints {
|
|
series.Points = append(series.Points, legacydata.DataTimePoint{null.FloatFrom(datapoints[idx]), null.FloatFrom(1234134)})
|
|
}
|
|
|
|
return reducer.Reduce(series).Float64
|
|
}
|