opensource/grafana
1
0
Fork 0
mirror of https://github.com/grafana/grafana.git synced 2025-07-31 04:32:30 +08:00
Code Issues Packages Projects Releases Wiki Activity

Alerting: Improve test coverage for ConditionsCmd (#58603)

Browse Source
This commit is contained in:
George Robinson
2022-11-11 09:27:35 +00:00
committed by GitHub
parent c090de9ed9
commit bd87b46b15
4 changed files with 514 additions and 330 deletions
Download Patch File Download Diff File Expand all files Collapse all files

279
pkg/expr/classic/reduce_test.go
View File

@ -5,10 +5,11 @@ import (
"testing"
"time"
"github.com/grafana/grafana-plugin-sdk-go/data"
"github.com/grafana/grafana/pkg/expr/mathexp"
"github.com/stretchr/testify/require"
ptr "github.com/xorcare/pointer"
"github.com/grafana/grafana-plugin-sdk-go/data"
"github.com/grafana/grafana/pkg/expr/mathexp"
)
func TestReducer(t *testing.T) {
@ -21,98 +22,98 @@ func TestReducer(t *testing.T) {
{
name: "sum",
reducer: reducer("sum"),
inputSeries: valBasedSeries(ptr.Float64(1), ptr.Float64(2), ptr.Float64(3)),
expectedNumber: valBasedNumber(ptr.Float64(6)),
inputSeries: newSeries(ptr.Float64(1), ptr.Float64(2), ptr.Float64(3)),
expectedNumber: newNumber(ptr.Float64(6)),
},
{
name: "min",
reducer: reducer("min"),
inputSeries: valBasedSeries(ptr.Float64(3), ptr.Float64(2), ptr.Float64(1)),
expectedNumber: valBasedNumber(ptr.Float64(1)),
inputSeries: newSeries(ptr.Float64(3), ptr.Float64(2), ptr.Float64(1)),
expectedNumber: newNumber(ptr.Float64(1)),
},
{
name: "min with NaNs only",
reducer: reducer("min"),
inputSeries: valBasedSeries(ptr.Float64(math.NaN()), ptr.Float64(math.NaN()), ptr.Float64(math.NaN())),
expectedNumber: valBasedNumber(nil),
inputSeries: newSeries(ptr.Float64(math.NaN()), ptr.Float64(math.NaN()), ptr.Float64(math.NaN())),
expectedNumber: newNumber(nil),
},
{
name: "max",
reducer: reducer("max"),
inputSeries: valBasedSeries(ptr.Float64(1), ptr.Float64(2), ptr.Float64(3)),
expectedNumber: valBasedNumber(ptr.Float64(3)),
inputSeries: newSeries(ptr.Float64(1), ptr.Float64(2), ptr.Float64(3)),
expectedNumber: newNumber(ptr.Float64(3)),
},
{
name: "count",
reducer: reducer("count"),
inputSeries: valBasedSeries(ptr.Float64(1), ptr.Float64(2), ptr.Float64(3000)),
expectedNumber: valBasedNumber(ptr.Float64(3)),
inputSeries: newSeries(ptr.Float64(1), ptr.Float64(2), ptr.Float64(3000)),
expectedNumber: newNumber(ptr.Float64(3)),
},
{
name: "last",
reducer: reducer("last"),
inputSeries: valBasedSeries(ptr.Float64(1), ptr.Float64(2), ptr.Float64(3000)),
expectedNumber: valBasedNumber(ptr.Float64(3000)),
inputSeries: newSeries(ptr.Float64(1), ptr.Float64(2), ptr.Float64(3000)),
expectedNumber: newNumber(ptr.Float64(3000)),
},
{
name: "median with odd amount of numbers",
reducer: reducer("median"),
inputSeries: valBasedSeries(ptr.Float64(1), ptr.Float64(2), ptr.Float64(3000)),
expectedNumber: valBasedNumber(ptr.Float64(2)),
inputSeries: newSeries(ptr.Float64(1), ptr.Float64(2), ptr.Float64(3000)),
expectedNumber: newNumber(ptr.Float64(2)),
},
{
name: "median with even amount of numbers",
reducer: reducer("median"),
inputSeries: valBasedSeries(ptr.Float64(1), ptr.Float64(2), ptr.Float64(4), ptr.Float64(3000)),
expectedNumber: valBasedNumber(ptr.Float64(3)),
inputSeries: newSeries(ptr.Float64(1), ptr.Float64(2), ptr.Float64(4), ptr.Float64(3000)),
expectedNumber: newNumber(ptr.Float64(3)),
},
{
name: "median with one value",
reducer: reducer("median"),
inputSeries: valBasedSeries(ptr.Float64(1)),
expectedNumber: valBasedNumber(ptr.Float64(1)),
inputSeries: newSeries(ptr.Float64(1)),
expectedNumber: newNumber(ptr.Float64(1)),
},
{
name: "median should ignore null values",
reducer: reducer("median"),
inputSeries: valBasedSeries(nil, nil, nil, ptr.Float64(1), ptr.Float64(2), ptr.Float64(3)),
expectedNumber: valBasedNumber(ptr.Float64(2)),
inputSeries: newSeries(nil, nil, nil, ptr.Float64(1), ptr.Float64(2), ptr.Float64(3)),
expectedNumber: newNumber(ptr.Float64(2)),
},
{
name: "avg",
reducer: reducer("avg"),
inputSeries: valBasedSeries(ptr.Float64(1), ptr.Float64(2), ptr.Float64(3)),
expectedNumber: valBasedNumber(ptr.Float64(2)),
inputSeries: newSeries(ptr.Float64(1), ptr.Float64(2), ptr.Float64(3)),
expectedNumber: newNumber(ptr.Float64(2)),
},
{
name: "avg with only nulls",
reducer: reducer("avg"),
inputSeries: valBasedSeries(nil),
expectedNumber: valBasedNumber(nil),
inputSeries: newSeries(nil),
expectedNumber: newNumber(nil),
},
{
name: "avg of number values and null values should ignore nulls",
reducer: reducer("avg"),
inputSeries: valBasedSeries(ptr.Float64(3), nil, nil, ptr.Float64(3)),
expectedNumber: valBasedNumber(ptr.Float64(3)),
inputSeries: newSeries(ptr.Float64(3), nil, nil, ptr.Float64(3)),
expectedNumber: newNumber(ptr.Float64(3)),
},
{
name: "count_non_null with mixed null/real values",
reducer: reducer("count_non_null"),
inputSeries: valBasedSeries(nil, nil, ptr.Float64(3), ptr.Float64(4)),
expectedNumber: valBasedNumber(ptr.Float64(2)),
inputSeries: newSeries(nil, nil, ptr.Float64(3), ptr.Float64(4)),
expectedNumber: newNumber(ptr.Float64(2)),
},
{
name: "count_non_null with mixed null/real values",
reducer: reducer("count_non_null"),
inputSeries: valBasedSeries(nil, nil, ptr.Float64(3), ptr.Float64(4)),
expectedNumber: valBasedNumber(ptr.Float64(2)),
inputSeries: newSeries(nil, nil, ptr.Float64(3), ptr.Float64(4)),
expectedNumber: newNumber(ptr.Float64(2)),
},
{
name: "count_non_null with no values",
reducer: reducer("count_non_null"),
inputSeries: valBasedSeries(nil, nil),
expectedNumber: valBasedNumber(nil),
inputSeries: newSeries(nil, nil),
expectedNumber: newNumber(nil),
},
}
@ -133,58 +134,58 @@ func TestDiffReducer(t *testing.T) {
}{
{
name: "diff of one positive point",
inputSeries: valBasedSeries(ptr.Float64(30)),
expectedNumber: valBasedNumber(ptr.Float64(0)),
inputSeries: newSeries(ptr.Float64(30)),
expectedNumber: newNumber(ptr.Float64(0)),
},
{
name: "diff of one negative point",
inputSeries: valBasedSeries(ptr.Float64(-30)),
expectedNumber: valBasedNumber(ptr.Float64(0)),
inputSeries: newSeries(ptr.Float64(-30)),
expectedNumber: newNumber(ptr.Float64(0)),
},
{
name: "diff two positive points [1]",
inputSeries: valBasedSeries(ptr.Float64(30), ptr.Float64(40)),
expectedNumber: valBasedNumber(ptr.Float64(10)),
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(40)),
expectedNumber: newNumber(ptr.Float64(10)),
},
{
name: "diff two positive points [2]",
inputSeries: valBasedSeries(ptr.Float64(30), ptr.Float64(20)),
expectedNumber: valBasedNumber(ptr.Float64(-10)),
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(20)),
expectedNumber: newNumber(ptr.Float64(-10)),
},
{
name: "diff two negative points [1]",
inputSeries: valBasedSeries(ptr.Float64(-30), ptr.Float64(-40)),
expectedNumber: valBasedNumber(ptr.Float64(-10)),
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(-40)),
expectedNumber: newNumber(ptr.Float64(-10)),
},
{
name: "diff two negative points [2]",
inputSeries: valBasedSeries(ptr.Float64(-30), ptr.Float64(-10)),
expectedNumber: valBasedNumber(ptr.Float64(20)),
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(-10)),
expectedNumber: newNumber(ptr.Float64(20)),
},
{
name: "diff of one positive and one negative point",
inputSeries: valBasedSeries(ptr.Float64(30), ptr.Float64(-40)),
expectedNumber: valBasedNumber(ptr.Float64(-70)),
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(-40)),
expectedNumber: newNumber(ptr.Float64(-70)),
},
{
name: "diff of one negative and one positive point",
inputSeries: valBasedSeries(ptr.Float64(-30), ptr.Float64(40)),
expectedNumber: valBasedNumber(ptr.Float64(70)),
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(40)),
expectedNumber: newNumber(ptr.Float64(70)),
},
{
name: "diff of three positive points",
inputSeries: valBasedSeries(ptr.Float64(30), ptr.Float64(40), ptr.Float64(50)),
expectedNumber: valBasedNumber(ptr.Float64(20)),
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(40), ptr.Float64(50)),
expectedNumber: newNumber(ptr.Float64(20)),
},
{
name: "diff of three negative points",
inputSeries: valBasedSeries(ptr.Float64(-30), ptr.Float64(-40), ptr.Float64(-50)),
expectedNumber: valBasedNumber(ptr.Float64(-20)),
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(-40), ptr.Float64(-50)),
expectedNumber: newNumber(ptr.Float64(-20)),
},
{
name: "diff with only nulls",
inputSeries: valBasedSeries(nil, nil),
expectedNumber: valBasedNumber(nil),
inputSeries: newSeries(nil, nil),
expectedNumber: newNumber(nil),
},
}
for _, tt := range tests {
@ -203,58 +204,58 @@ func TestDiffAbsReducer(t *testing.T) {
}{
{
name: "diff_abs of one positive point",
inputSeries: valBasedSeries(ptr.Float64(30)),
expectedNumber: valBasedNumber(ptr.Float64(0)),
inputSeries: newSeries(ptr.Float64(30)),
expectedNumber: newNumber(ptr.Float64(0)),
},
{
name: "diff_abs of one negative point",
inputSeries: valBasedSeries(ptr.Float64(-30)),
expectedNumber: valBasedNumber(ptr.Float64(0)),
inputSeries: newSeries(ptr.Float64(-30)),
expectedNumber: newNumber(ptr.Float64(0)),
},
{
name: "diff_abs two positive points [1]",
inputSeries: valBasedSeries(ptr.Float64(30), ptr.Float64(40)),
expectedNumber: valBasedNumber(ptr.Float64(10)),
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(40)),
expectedNumber: newNumber(ptr.Float64(10)),
},
{
name: "diff_abs two positive points [2]",
inputSeries: valBasedSeries(ptr.Float64(30), ptr.Float64(20)),
expectedNumber: valBasedNumber(ptr.Float64(10)),
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(20)),
expectedNumber: newNumber(ptr.Float64(10)),
},
{
name: "diff_abs two negative points [1]",
inputSeries: valBasedSeries(ptr.Float64(-30), ptr.Float64(-40)),
expectedNumber: valBasedNumber(ptr.Float64(10)),
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(-40)),
expectedNumber: newNumber(ptr.Float64(10)),
},
{
name: "diff_abs two negative points [2]",
inputSeries: valBasedSeries(ptr.Float64(-30), ptr.Float64(-10)),
expectedNumber: valBasedNumber(ptr.Float64(20)),
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(-10)),
expectedNumber: newNumber(ptr.Float64(20)),
},
{
name: "diff_abs of one positive and one negative point",
inputSeries: valBasedSeries(ptr.Float64(30), ptr.Float64(-40)),
expectedNumber: valBasedNumber(ptr.Float64(70)),
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(-40)),
expectedNumber: newNumber(ptr.Float64(70)),
},
{
name: "diff_abs of one negative and one positive point",
inputSeries: valBasedSeries(ptr.Float64(-30), ptr.Float64(40)),
expectedNumber: valBasedNumber(ptr.Float64(70)),
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(40)),
expectedNumber: newNumber(ptr.Float64(70)),
},
{
name: "diff_abs of three positive points",
inputSeries: valBasedSeries(ptr.Float64(30), ptr.Float64(40), ptr.Float64(50)),
expectedNumber: valBasedNumber(ptr.Float64(20)),
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(40), ptr.Float64(50)),
expectedNumber: newNumber(ptr.Float64(20)),
},
{
name: "diff_abs of three negative points",
inputSeries: valBasedSeries(ptr.Float64(-30), ptr.Float64(-40), ptr.Float64(-50)),
expectedNumber: valBasedNumber(ptr.Float64(20)),
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(-40), ptr.Float64(-50)),
expectedNumber: newNumber(ptr.Float64(20)),
},
{
name: "diff_abs with only nulls",
inputSeries: valBasedSeries(nil, nil),
expectedNumber: valBasedNumber(nil),
inputSeries: newSeries(nil, nil),
expectedNumber: newNumber(nil),
},
}
for _, tt := range tests {
@ -273,58 +274,58 @@ func TestPercentDiffReducer(t *testing.T) {
}{
{
name: "percent_diff of one positive point",
inputSeries: valBasedSeries(ptr.Float64(30)),
expectedNumber: valBasedNumber(ptr.Float64(0)),
inputSeries: newSeries(ptr.Float64(30)),
expectedNumber: newNumber(ptr.Float64(0)),
},
{
name: "percent_diff of one negative point",
inputSeries: valBasedSeries(ptr.Float64(-30)),
expectedNumber: valBasedNumber(ptr.Float64(0)),
inputSeries: newSeries(ptr.Float64(-30)),
expectedNumber: newNumber(ptr.Float64(0)),
},
{
name: "percent_diff two positive points [1]",
inputSeries: valBasedSeries(ptr.Float64(30), ptr.Float64(40)),
expectedNumber: valBasedNumber(ptr.Float64(33.33333333333333)),
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(40)),
expectedNumber: newNumber(ptr.Float64(33.33333333333333)),
},
{
name: "percent_diff two positive points [2]",
inputSeries: valBasedSeries(ptr.Float64(30), ptr.Float64(20)),
expectedNumber: valBasedNumber(ptr.Float64(-33.33333333333333)),
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(20)),
expectedNumber: newNumber(ptr.Float64(-33.33333333333333)),
},
{
name: "percent_diff two negative points [1]",
inputSeries: valBasedSeries(ptr.Float64(-30), ptr.Float64(-40)),
expectedNumber: valBasedNumber(ptr.Float64(-33.33333333333333)),
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(-40)),
expectedNumber: newNumber(ptr.Float64(-33.33333333333333)),
},
{
name: "percent_diff two negative points [2]",
inputSeries: valBasedSeries(ptr.Float64(-30), ptr.Float64(-10)),
expectedNumber: valBasedNumber(ptr.Float64(66.66666666666666)),
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(-10)),
expectedNumber: newNumber(ptr.Float64(66.66666666666666)),
},
{
name: "percent_diff of one positive and one negative point",
inputSeries: valBasedSeries(ptr.Float64(30), ptr.Float64(-40)),
expectedNumber: valBasedNumber(ptr.Float64(-233.33333333333334)),
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(-40)),
expectedNumber: newNumber(ptr.Float64(-233.33333333333334)),
},
{
name: "percent_diff of one negative and one positive point",
inputSeries: valBasedSeries(ptr.Float64(-30), ptr.Float64(40)),
expectedNumber: valBasedNumber(ptr.Float64(233.33333333333334)),
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(40)),
expectedNumber: newNumber(ptr.Float64(233.33333333333334)),
},
{
name: "percent_diff of three positive points",
inputSeries: valBasedSeries(ptr.Float64(30), ptr.Float64(40), ptr.Float64(50)),
expectedNumber: valBasedNumber(ptr.Float64(66.66666666666666)),
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(40), ptr.Float64(50)),
expectedNumber: newNumber(ptr.Float64(66.66666666666666)),
},
{
name: "percent_diff of three negative points",
inputSeries: valBasedSeries(ptr.Float64(-30), ptr.Float64(-40), ptr.Float64(-50)),
expectedNumber: valBasedNumber(ptr.Float64(-66.66666666666666)),
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(-40), ptr.Float64(-50)),
expectedNumber: newNumber(ptr.Float64(-66.66666666666666)),
},
{
name: "percent_diff with only nulls",
inputSeries: valBasedSeries(nil, nil),
expectedNumber: valBasedNumber(nil),
inputSeries: newSeries(nil, nil),
expectedNumber: newNumber(nil),
},
}
for _, tt := range tests {
@ -343,58 +344,58 @@ func TestPercentDiffAbsReducer(t *testing.T) {
}{
{
name: "percent_diff_abs of one positive point",
inputSeries: valBasedSeries(ptr.Float64(30)),
expectedNumber: valBasedNumber(ptr.Float64(0)),
inputSeries: newSeries(ptr.Float64(30)),
expectedNumber: newNumber(ptr.Float64(0)),
},
{
name: "percent_diff_abs of one negative point",
inputSeries: valBasedSeries(ptr.Float64(-30)),
expectedNumber: valBasedNumber(ptr.Float64(0)),
inputSeries: newSeries(ptr.Float64(-30)),
expectedNumber: newNumber(ptr.Float64(0)),
},
{
name: "percent_diff_abs two positive points [1]",
inputSeries: valBasedSeries(ptr.Float64(30), ptr.Float64(40)),
expectedNumber: valBasedNumber(ptr.Float64(33.33333333333333)),
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(40)),
expectedNumber: newNumber(ptr.Float64(33.33333333333333)),
},
{
name: "percent_diff_abs two positive points [2]",
inputSeries: valBasedSeries(ptr.Float64(30), ptr.Float64(20)),
expectedNumber: valBasedNumber(ptr.Float64(33.33333333333333)),
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(20)),
expectedNumber: newNumber(ptr.Float64(33.33333333333333)),
},
{
name: "percent_diff_abs two negative points [1]",
inputSeries: valBasedSeries(ptr.Float64(-30), ptr.Float64(-40)),
expectedNumber: valBasedNumber(ptr.Float64(33.33333333333333)),
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(-40)),
expectedNumber: newNumber(ptr.Float64(33.33333333333333)),
},
{
name: "percent_diff_abs two negative points [2]",
inputSeries: valBasedSeries(ptr.Float64(-30), ptr.Float64(-10)),
expectedNumber: valBasedNumber(ptr.Float64(66.66666666666666)),
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(-10)),
expectedNumber: newNumber(ptr.Float64(66.66666666666666)),
},
{
name: "percent_diff_abs of one positive and one negative point",
inputSeries: valBasedSeries(ptr.Float64(30), ptr.Float64(-40)),
expectedNumber: valBasedNumber(ptr.Float64(233.33333333333334)),
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(-40)),
expectedNumber: newNumber(ptr.Float64(233.33333333333334)),
},
{
name: "percent_diff_abs of one negative and one positive point",
inputSeries: valBasedSeries(ptr.Float64(-30), ptr.Float64(40)),
expectedNumber: valBasedNumber(ptr.Float64(233.33333333333334)),
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(40)),
expectedNumber: newNumber(ptr.Float64(233.33333333333334)),
},
{
name: "percent_diff_abs of three positive points",
inputSeries: valBasedSeries(ptr.Float64(30), ptr.Float64(40), ptr.Float64(50)),
expectedNumber: valBasedNumber(ptr.Float64(66.66666666666666)),
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(40), ptr.Float64(50)),
expectedNumber: newNumber(ptr.Float64(66.66666666666666)),
},
{
name: "percent_diff_abs of three negative points",
inputSeries: valBasedSeries(ptr.Float64(-30), ptr.Float64(-40), ptr.Float64(-50)),
expectedNumber: valBasedNumber(ptr.Float64(66.66666666666666)),
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(-40), ptr.Float64(-50)),
expectedNumber: newNumber(ptr.Float64(66.66666666666666)),
},
{
name: "percent_diff_abs with only nulls",
inputSeries: valBasedSeries(nil, nil),
expectedNumber: valBasedNumber(nil),
inputSeries: newSeries(nil, nil),
expectedNumber: newNumber(nil),
},
}
for _, tt := range tests {
@ -405,24 +406,28 @@ func TestPercentDiffAbsReducer(t *testing.T) {
}
}
func valBasedSeries(vals ...*float64) mathexp.Series {
newSeries := mathexp.NewSeries("", nil, len(vals))
for idx, f := range vals {
newSeries.SetPoint(idx, time.Unix(int64(idx), 0), f)
}
return newSeries
func newNumber(f *float64) mathexp.Number {
num := mathexp.NewNumber("", nil)
num.SetValue(f)
return num
}
func valBasedSeriesWithLabels(l data.Labels, vals ...*float64) mathexp.Series {
newSeries := mathexp.NewSeries("", l, len(vals))
for idx, f := range vals {
newSeries.SetPoint(idx, time.Unix(int64(idx), 0), f)
func newSeries(points ...*float64) mathexp.Series {
series := mathexp.NewSeries("", nil, len(points))
for idx, point := range points {
series.SetPoint(idx, time.Unix(int64(idx), 0), point)
}
return newSeries
return series
}
func valBasedNumber(f *float64) mathexp.Number {
newNumber := mathexp.NewNumber("", nil)
newNumber.SetValue(f)
return newNumber
func newSeriesWithLabels(labels data.Labels, values ...*float64) mathexp.Series {
series := mathexp.NewSeries("", labels, len(values))
for idx, value := range values {
series.SetPoint(idx, time.Unix(int64(idx), 0), value)
}
return series
}
func newResults(values ...mathexp.Value) mathexp.Results {
return mathexp.Results{Values: values}
}