public/grafana
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Chore: Remove xorcare/pointer dependency (#63900)

Browse Source 
* Chore: remove pointer dependency

* fix type casts

* deprecate xorcare/pointer library in linter

* rooky mistake
This commit is contained in:
Serge Zaitsev
2023-03-06 05:23:15 -05:00
committed by GitHub
parent 30c6ac49ba
commit 0bdb105df2
23 changed files with 469 additions and 471 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pkg/expr/classic/classic_test.go
+55 -55
View File
@@ -8,9 +8,9 @@ import (
"github.com/grafana/grafana-plugin-sdk-go/data"
"github.com/stretchr/testify/require"
ptr "github.com/xorcare/pointer"
"github.com/grafana/grafana/pkg/expr/mathexp"
"github.com/grafana/grafana/pkg/util"
)
func TestConditionsCmd(t *testing.T) {
@@ -26,7 +26,7 @@ func TestConditionsCmd(t *testing.T) {
vars: mathexp.Vars{
"A": mathexp.Results{
Values: []mathexp.Value{
newSeries(ptr.Float64(1), ptr.Float64(5)),
newSeries(util.Pointer(1.0), util.Pointer(5.0)),
},
},
},
@@ -40,7 +40,7 @@ func TestConditionsCmd(t *testing.T) {
},
}},
expected: func() mathexp.Results {
v := newNumber(ptr.Float64(0))
v := newNumber(util.Pointer(0.0))
v.SetMeta([]EvalMatch{})
return newResults(v)
},
@@ -51,7 +51,7 @@ func TestConditionsCmd(t *testing.T) {
vars: mathexp.Vars{
"A": mathexp.Results{
Values: []mathexp.Value{
newSeries(ptr.Float64(1), ptr.Float64(5)),
newSeries(util.Pointer(1.0), util.Pointer(5.0)),
},
},
},
@@ -65,8 +65,8 @@ func TestConditionsCmd(t *testing.T) {
},
}},
expected: func() mathexp.Results {
v := newNumber(ptr.Float64(1))
v.SetMeta([]EvalMatch{{Value: ptr.Float64(3)}})
v := newNumber(util.Pointer(1.0))
v.SetMeta([]EvalMatch{{Value: util.Pointer(3.0)}})
return newResults(v)
},
}, {
@@ -74,7 +74,7 @@ func TestConditionsCmd(t *testing.T) {
vars: mathexp.Vars{
"A": mathexp.Results{
Values: []mathexp.Value{
newSeries(ptr.Float64(1), ptr.Float64(5)),
newSeries(util.Pointer(1.0), util.Pointer(5.0)),
},
},
},
@@ -89,7 +89,7 @@ func TestConditionsCmd(t *testing.T) {
},
},
expected: func() mathexp.Results {
v := newNumber(ptr.Float64(0))
v := newNumber(util.Pointer(0.0))
v.SetMeta([]EvalMatch{})
return newResults(v)
},
@@ -98,7 +98,7 @@ func TestConditionsCmd(t *testing.T) {
vars: mathexp.Vars{
"A": mathexp.Results{
Values: []mathexp.Value{
newSeries(ptr.Float64(1), ptr.Float64(5)),
newSeries(util.Pointer(1.0), util.Pointer(5.0)),
},
},
},
@@ -113,8 +113,8 @@ func TestConditionsCmd(t *testing.T) {
},
},
expected: func() mathexp.Results {
v := newNumber(ptr.Float64(1))
v.SetMeta([]EvalMatch{{Value: ptr.Float64(4)}})
v := newNumber(util.Pointer(1.0))
v.SetMeta([]EvalMatch{{Value: util.Pointer(4.0)}})
return newResults(v)
},
}, {
@@ -203,7 +203,7 @@ func TestConditionsCmd(t *testing.T) {
},
},
expected: func() mathexp.Results {
v := newNumber(ptr.Float64(1))
v := newNumber(util.Pointer(1.0))
v.SetMeta([]EvalMatch{{Value: nil}})
return newResults(v)
},
@@ -225,7 +225,7 @@ func TestConditionsCmd(t *testing.T) {
},
},
expected: func() mathexp.Results {
v := newNumber(ptr.Float64(1))
v := newNumber(util.Pointer(1.0))
v.SetMeta([]EvalMatch{{Value: nil}})
return newResults(v)
},
@@ -249,7 +249,7 @@ func TestConditionsCmd(t *testing.T) {
},
},
expected: func() mathexp.Results {
v := newNumber(ptr.Float64(1))
v := newNumber(util.Pointer(1.0))
v.SetMeta([]EvalMatch{{Value: nil}})
return newResults(v)
},
@@ -261,7 +261,7 @@ func TestConditionsCmd(t *testing.T) {
"A": mathexp.Results{
Values: []mathexp.Value{
newSeries(),
newSeries(ptr.Float64(2)),
newSeries(util.Pointer(2.0)),
},
},
},
@@ -275,8 +275,8 @@ func TestConditionsCmd(t *testing.T) {
},
}},
expected: func() mathexp.Results {
v := newNumber(ptr.Float64(1))
v.SetMeta([]EvalMatch{{Value: ptr.Float64(2)}})
v := newNumber(util.Pointer(1.0))
v.SetMeta([]EvalMatch{{Value: util.Pointer(2.0)}})
return newResults(v)
},
}, {
@@ -284,8 +284,8 @@ func TestConditionsCmd(t *testing.T) {
vars: mathexp.Vars{
"A": mathexp.Results{
Values: []mathexp.Value{
newSeries(ptr.Float64(1), ptr.Float64(5)),
newSeries(ptr.Float64(2), ptr.Float64(10)),
newSeries(util.Pointer(1.0), util.Pointer(5.0)),
newSeries(util.Pointer(2.0), util.Pointer(10.0)),
},
},
},
@@ -299,7 +299,7 @@ func TestConditionsCmd(t *testing.T) {
},
}},
expected: func() mathexp.Results {
v := newNumber(ptr.Float64(0))
v := newNumber(util.Pointer(0.0))
v.SetMeta([]EvalMatch{})
return mathexp.Results{Values: mathexp.Values{v}}
},
@@ -308,8 +308,8 @@ func TestConditionsCmd(t *testing.T) {
vars: mathexp.Vars{
"A": mathexp.Results{
Values: []mathexp.Value{
newSeries(ptr.Float64(1), ptr.Float64(5)),
newSeriesWithLabels(data.Labels{"foo": "bar"}, ptr.Float64(2), ptr.Float64(10)),
newSeries(util.Pointer(1.0), util.Pointer(5.0)),
newSeriesWithLabels(data.Labels{"foo": "bar"}, util.Pointer(2.0), util.Pointer(10.0)),
},
},
},
@@ -323,8 +323,8 @@ func TestConditionsCmd(t *testing.T) {
},
}},
expected: func() mathexp.Results {
v := newNumber(ptr.Float64(1))
v.SetMeta([]EvalMatch{{Value: ptr.Float64(2), Labels: data.Labels{"foo": "bar"}}})
v := newNumber(util.Pointer(1.0))
v.SetMeta([]EvalMatch{{Value: util.Pointer(2.0), Labels: data.Labels{"foo": "bar"}}})
return newResults(v)
},
}, {
@@ -332,8 +332,8 @@ func TestConditionsCmd(t *testing.T) {
vars: mathexp.Vars{
"A": mathexp.Results{
Values: []mathexp.Value{
newSeries(ptr.Float64(1), ptr.Float64(5)),
newSeriesWithLabels(data.Labels{"foo": "bar"}, ptr.Float64(2), ptr.Float64(10)),
newSeries(util.Pointer(1.0), util.Pointer(5.0)),
newSeriesWithLabels(data.Labels{"foo": "bar"}, util.Pointer(2.0), util.Pointer(10.0)),
},
},
},
@@ -347,11 +347,11 @@ func TestConditionsCmd(t *testing.T) {
},
}},
expected: func() mathexp.Results {
v := newNumber(ptr.Float64(1))
v := newNumber(util.Pointer(1.0))
v.SetMeta([]EvalMatch{{
Value: ptr.Float64(1),
Value: util.Pointer(1.0),
}, {
Value: ptr.Float64(2),
Value: util.Pointer(2.0),
Labels: data.Labels{"foo": "bar"},
}})
return newResults(v)
@@ -361,7 +361,7 @@ func TestConditionsCmd(t *testing.T) {
vars: mathexp.Vars{
"A": mathexp.Results{
Values: []mathexp.Value{
newSeries(ptr.Float64(1), ptr.Float64(5)),
newSeries(util.Pointer(1.0), util.Pointer(5.0)),
},
},
},
@@ -380,8 +380,8 @@ func TestConditionsCmd(t *testing.T) {
},
}},
expected: func() mathexp.Results {
v := newNumber(ptr.Float64(1))
v.SetMeta([]EvalMatch{{Value: ptr.Float64(5)}})
v := newNumber(util.Pointer(1.0))
v.SetMeta([]EvalMatch{{Value: util.Pointer(5.0)}})
return newResults(v)
},
}, {
@@ -389,7 +389,7 @@ func TestConditionsCmd(t *testing.T) {
vars: mathexp.Vars{
"A": mathexp.Results{
Values: []mathexp.Value{
newSeries(ptr.Float64(1), ptr.Float64(5)),
newSeries(util.Pointer(1.0), util.Pointer(5.0)),
},
},
},
@@ -408,8 +408,8 @@ func TestConditionsCmd(t *testing.T) {
},
}},
expected: func() mathexp.Results {
v := newNumber(ptr.Float64(1))
v.SetMeta([]EvalMatch{{Value: ptr.Float64(1)}})
v := newNumber(util.Pointer(1.0))
v.SetMeta([]EvalMatch{{Value: util.Pointer(1.0)}})
return newResults(v)
},
}, {
@@ -417,7 +417,7 @@ func TestConditionsCmd(t *testing.T) {
vars: mathexp.Vars{
"A": mathexp.Results{
Values: []mathexp.Value{
newSeries(ptr.Float64(1), ptr.Float64(5)),
newSeries(util.Pointer(1.0), util.Pointer(5.0)),
},
},
},
@@ -436,8 +436,8 @@ func TestConditionsCmd(t *testing.T) {
},
}},
expected: func() mathexp.Results {
v := newNumber(ptr.Float64(1))
v.SetMeta([]EvalMatch{{Value: ptr.Float64(5)}, {Value: ptr.Float64(1)}})
v := newNumber(util.Pointer(1.0))
v.SetMeta([]EvalMatch{{Value: util.Pointer(5.0)}, {Value: util.Pointer(1.0)}})
return newResults(v)
},
}, {
@@ -445,9 +445,9 @@ func TestConditionsCmd(t *testing.T) {
vars: mathexp.Vars{
"A": mathexp.Results{
Values: []mathexp.Value{
newNumber(ptr.Float64(5)),
newNumber(ptr.Float64(10)),
newNumber(ptr.Float64(15)),
newNumber(util.Pointer(5.0)),
newNumber(util.Pointer(10.0)),
newNumber(util.Pointer(15.0)),
},
},
},
@@ -462,11 +462,11 @@ func TestConditionsCmd(t *testing.T) {
},
},
expected: func() mathexp.Results {
v := newNumber(ptr.Float64(1))
v := newNumber(util.Pointer(1.0))
v.SetMeta([]EvalMatch{
{Value: ptr.Float64(5)},
{Value: ptr.Float64(10)},
{Value: ptr.Float64(15)},
{Value: util.Pointer(5.0)},
{Value: util.Pointer(10.0)},
{Value: util.Pointer(15.0)},
})
return newResults(v)
},
@@ -477,7 +477,7 @@ func TestConditionsCmd(t *testing.T) {
Values: []mathexp.Value{mathexp.NoData{}.New()},
},
"B": mathexp.Results{
Values: []mathexp.Value{newSeries(ptr.Float64(5))},
Values: []mathexp.Value{newSeries(util.Pointer(5.0))},
},
},
cmd: &ConditionsCmd{
@@ -497,15 +497,15 @@ func TestConditionsCmd(t *testing.T) {
},
},
expected: func() mathexp.Results {
v := newNumber(ptr.Float64(0))
v.SetMeta([]EvalMatch{{Metric: "NoData"}, {Value: ptr.Float64(5)}})
v := newNumber(util.Pointer(0.0))
v.SetMeta([]EvalMatch{{Metric: "NoData"}, {Value: util.Pointer(5.0)}})
return newResults(v)
},
}, {
name: "two queries with two conditions using and operator and last is No Data",
vars: mathexp.Vars{
"A": mathexp.Results{
Values: []mathexp.Value{newSeries(ptr.Float64(5))},
Values: []mathexp.Value{newSeries(util.Pointer(5.0))},
},
"B": mathexp.Results{
Values: []mathexp.Value{mathexp.NoData{}.New()},
@@ -528,8 +528,8 @@ func TestConditionsCmd(t *testing.T) {
},
},
expected: func() mathexp.Results {
v := newNumber(ptr.Float64(0))
v.SetMeta([]EvalMatch{{Value: ptr.Float64(5)}, {Metric: "NoData"}})
v := newNumber(util.Pointer(0.0))
v.SetMeta([]EvalMatch{{Value: util.Pointer(5.0)}, {Metric: "NoData"}})
return newResults(v)
},
}, {
@@ -539,7 +539,7 @@ func TestConditionsCmd(t *testing.T) {
Values: []mathexp.Value{mathexp.NoData{}.New()},
},
"B": mathexp.Results{
Values: []mathexp.Value{newSeries(ptr.Float64(5))},
Values: []mathexp.Value{newSeries(util.Pointer(5.0))},
},
},
cmd: &ConditionsCmd{
@@ -560,14 +560,14 @@ func TestConditionsCmd(t *testing.T) {
},
expected: func() mathexp.Results {
v := newNumber(nil)
v.SetMeta([]EvalMatch{{Metric: "NoData"}, {Value: ptr.Float64(5)}})
v.SetMeta([]EvalMatch{{Metric: "NoData"}, {Value: util.Pointer(5.0)}})
return newResults(v)
},
}, {
name: "two queries with two conditions using or operator and last is No Data",
vars: mathexp.Vars{
"A": mathexp.Results{
Values: []mathexp.Value{newSeries(ptr.Float64(5))},
Values: []mathexp.Value{newSeries(util.Pointer(5.0))},
},
"B": mathexp.Results{
Values: []mathexp.Value{mathexp.NoData{}.New()},
@@ -591,7 +591,7 @@ func TestConditionsCmd(t *testing.T) {
},
expected: func() mathexp.Results {
v := newNumber(nil)
v.SetMeta([]EvalMatch{{Value: ptr.Float64(5)}, {Metric: "NoData"}})
v.SetMeta([]EvalMatch{{Value: util.Pointer(5.0)}, {Metric: "NoData"}})
return newResults(v)
},
}}
pkg/expr/classic/evaluator_test.go
+14 -14
View File
@@ -4,9 +4,9 @@ import (
"testing"
"github.com/stretchr/testify/require"
ptr "github.com/xorcare/pointer"
"github.com/grafana/grafana/pkg/expr/mathexp"
"github.com/grafana/grafana/pkg/util"
)
func TestThresholdEvaluator(t *testing.T) {
@@ -19,25 +19,25 @@ func TestThresholdEvaluator(t *testing.T) {
{
name: "value 3 is gt 1: true",
evaluator: &thresholdEvaluator{"gt", 1},
inputNumber: newNumber(ptr.Float64(3)),
inputNumber: newNumber(util.Pointer(3.0)),
expected: true,
},
{
name: "value 1 is gt 3: false",
evaluator: &thresholdEvaluator{"gt", 3},
inputNumber: newNumber(ptr.Float64(1)),
inputNumber: newNumber(util.Pointer(1.0)),
expected: false,
},
{
name: "value 3 is lt 1: true",
evaluator: &thresholdEvaluator{"lt", 1},
inputNumber: newNumber(ptr.Float64(3)),
inputNumber: newNumber(util.Pointer(3.0)),
expected: false,
},
{
name: "value 1 is lt 3: false",
evaluator: &thresholdEvaluator{"lt", 3},
inputNumber: newNumber(ptr.Float64(1)),
inputNumber: newNumber(util.Pointer(1.0)),
expected: true,
},
}
@@ -60,50 +60,50 @@ func TestRangedEvaluator(t *testing.T) {
{
name: "value 3 is within range 1, 100: true",
evaluator: &rangedEvaluator{"within_range", 1, 100},
inputNumber: newNumber(ptr.Float64(3)),
inputNumber: newNumber(util.Pointer(3.0)),
expected: true,
},
{
name: "value 300 is within range 1, 100: false",
evaluator: &rangedEvaluator{"within_range", 1, 100},
inputNumber: newNumber(ptr.Float64(300)),
inputNumber: newNumber(util.Pointer(300.0)),
expected: false,
},
{
name: "value 3 is within range 100, 1: true",
evaluator: &rangedEvaluator{"within_range", 100, 1},
inputNumber: newNumber(ptr.Float64(3)),
inputNumber: newNumber(util.Pointer(3.0)),
expected: true,
},
{
name: "value 300 is within range 100, 1: false",
evaluator: &rangedEvaluator{"within_range", 100, 1},
inputNumber: newNumber(ptr.Float64(300)),
inputNumber: newNumber(util.Pointer(300.0)),
expected: false,
},
// outside
{
name: "value 1000 is outside range 1, 100: true",
evaluator: &rangedEvaluator{"outside_range", 1, 100},
inputNumber: newNumber(ptr.Float64(1000)),
inputNumber: newNumber(util.Pointer(1000.0)),
expected: true,
},
{
name: "value 50 is outside range 1, 100: false",
evaluator: &rangedEvaluator{"outside_range", 1, 100},
inputNumber: newNumber(ptr.Float64(50)),
inputNumber: newNumber(util.Pointer(50.0)),
expected: false,
},
{
name: "value 1000 is outside range 100, 1: true",
evaluator: &rangedEvaluator{"outside_range", 100, 1},
inputNumber: newNumber(ptr.Float64(1000)),
inputNumber: newNumber(util.Pointer(1000.0)),
expected: true,
},
{
name: "value 50 is outside range 100, 1: false",
evaluator: &rangedEvaluator{"outside_range", 100, 1},
inputNumber: newNumber(ptr.Float64(50)),
inputNumber: newNumber(util.Pointer(50.0)),
expected: false,
},
}
@@ -125,7 +125,7 @@ func TestNoValueEvaluator(t *testing.T) {
{
name: "value 50 is no_value: false",
evaluator: &noValueEvaluator{},
inputNumber: newNumber(ptr.Float64(50)),
inputNumber: newNumber(util.Pointer(50.0)),
expected: false,
},
{
pkg/expr/classic/reduce_test.go
+108 -108
View File
@@ -7,9 +7,9 @@ import (
"github.com/grafana/grafana-plugin-sdk-go/data"
"github.com/stretchr/testify/require"
ptr "github.com/xorcare/pointer"
"github.com/grafana/grafana/pkg/expr/mathexp"
"github.com/grafana/grafana/pkg/util"
)
func TestReducer(t *testing.T) {
@@ -22,68 +22,68 @@ func TestReducer(t *testing.T) {
{
name: "sum",
reducer: reducer("sum"),
inputSeries: newSeries(ptr.Float64(1), ptr.Float64(2), ptr.Float64(3)),
expectedNumber: newNumber(ptr.Float64(6)),
inputSeries: newSeries(util.Pointer(1.0), util.Pointer(2.0), util.Pointer(3.0)),
expectedNumber: newNumber(util.Pointer(6.0)),
},
{
name: "min",
reducer: reducer("min"),
inputSeries: newSeries(ptr.Float64(3), ptr.Float64(2), ptr.Float64(1)),
expectedNumber: newNumber(ptr.Float64(1)),
inputSeries: newSeries(util.Pointer(3.0), util.Pointer(2.0), util.Pointer(1.0)),
expectedNumber: newNumber(util.Pointer(1.0)),
},
{
name: "min with NaNs only",
reducer: reducer("min"),
inputSeries: newSeries(ptr.Float64(math.NaN()), ptr.Float64(math.NaN()), ptr.Float64(math.NaN())),
inputSeries: newSeries(util.Pointer(math.NaN()), util.Pointer(math.NaN()), util.Pointer(math.NaN())),
expectedNumber: newNumber(nil),
},
{
name: "max",
reducer: reducer("max"),
inputSeries: newSeries(ptr.Float64(1), ptr.Float64(2), ptr.Float64(3)),
expectedNumber: newNumber(ptr.Float64(3)),
inputSeries: newSeries(util.Pointer(1.0), util.Pointer(2.0), util.Pointer(3.0)),
expectedNumber: newNumber(util.Pointer(3.0)),
},
{
name: "count",
reducer: reducer("count"),
inputSeries: newSeries(ptr.Float64(1), ptr.Float64(2), ptr.Float64(3000)),
expectedNumber: newNumber(ptr.Float64(3)),
inputSeries: newSeries(util.Pointer(1.0), util.Pointer(2.0), util.Pointer(3000.0)),
expectedNumber: newNumber(util.Pointer(3.0)),
},
{
name: "last",
reducer: reducer("last"),
inputSeries: newSeries(ptr.Float64(1), ptr.Float64(2), ptr.Float64(3000)),
expectedNumber: newNumber(ptr.Float64(3000)),
inputSeries: newSeries(util.Pointer(1.0), util.Pointer(2.0), util.Pointer(3000.0)),
expectedNumber: newNumber(util.Pointer(3000.0)),
},
{
name: "median with odd amount of numbers",
reducer: reducer("median"),
inputSeries: newSeries(ptr.Float64(1), ptr.Float64(2), ptr.Float64(3000)),
expectedNumber: newNumber(ptr.Float64(2)),
inputSeries: newSeries(util.Pointer(1.0), util.Pointer(2.0), util.Pointer(3000.0)),
expectedNumber: newNumber(util.Pointer(2.0)),
},
{
name: "median with even amount of numbers",
reducer: reducer("median"),
inputSeries: newSeries(ptr.Float64(1), ptr.Float64(2), ptr.Float64(4), ptr.Float64(3000)),
expectedNumber: newNumber(ptr.Float64(3)),
inputSeries: newSeries(util.Pointer(1.0), util.Pointer(2.0), util.Pointer(4.0), util.Pointer(3000.0)),
expectedNumber: newNumber(util.Pointer(3.0)),
},
{
name: "median with one value",
reducer: reducer("median"),
inputSeries: newSeries(ptr.Float64(1)),
expectedNumber: newNumber(ptr.Float64(1)),
inputSeries: newSeries(util.Pointer(1.0)),
expectedNumber: newNumber(util.Pointer(1.0)),
},
{
name: "median should ignore null values",
reducer: reducer("median"),
inputSeries: newSeries(nil, nil, nil, ptr.Float64(1), ptr.Float64(2), ptr.Float64(3)),
expectedNumber: newNumber(ptr.Float64(2)),
inputSeries: newSeries(nil, nil, nil, util.Pointer(1.0), util.Pointer(2.0), util.Pointer(3.0)),
expectedNumber: newNumber(util.Pointer(2.0)),
},
{
name: "avg",
reducer: reducer("avg"),
inputSeries: newSeries(ptr.Float64(1), ptr.Float64(2), ptr.Float64(3)),
expectedNumber: newNumber(ptr.Float64(2)),
inputSeries: newSeries(util.Pointer(1.0), util.Pointer(2.0), util.Pointer(3.0)),
expectedNumber: newNumber(util.Pointer(2.0)),
},
{
name: "avg with only nulls",
@@ -94,20 +94,20 @@ func TestReducer(t *testing.T) {
{
name: "avg of number values and null values should ignore nulls",
reducer: reducer("avg"),
inputSeries: newSeries(ptr.Float64(3), nil, nil, ptr.Float64(3)),
expectedNumber: newNumber(ptr.Float64(3)),
inputSeries: newSeries(util.Pointer(3.0), nil, nil, util.Pointer(3.0)),
expectedNumber: newNumber(util.Pointer(3.0)),
},
{
name: "count_non_null with mixed null/real values",
reducer: reducer("count_non_null"),
inputSeries: newSeries(nil, nil, ptr.Float64(3), ptr.Float64(4)),
expectedNumber: newNumber(ptr.Float64(2)),
inputSeries: newSeries(nil, nil, util.Pointer(3.0), util.Pointer(4.0)),
expectedNumber: newNumber(util.Pointer(2.0)),
},
{
name: "count_non_null with mixed null/real values",
reducer: reducer("count_non_null"),
inputSeries: newSeries(nil, nil, ptr.Float64(3), ptr.Float64(4)),
expectedNumber: newNumber(ptr.Float64(2)),
inputSeries: newSeries(nil, nil, util.Pointer(3.0), util.Pointer(4.0)),
expectedNumber: newNumber(util.Pointer(2.0)),
},
{
name: "count_non_null with no values",
@@ -134,53 +134,53 @@ func TestDiffReducer(t *testing.T) {
}{
{
name: "diff of one positive point",
inputSeries: newSeries(ptr.Float64(30)),
expectedNumber: newNumber(ptr.Float64(0)),
inputSeries: newSeries(util.Pointer(30.0)),
expectedNumber: newNumber(util.Pointer(0.0)),
},
{
name: "diff of one negative point",
inputSeries: newSeries(ptr.Float64(-30)),
expectedNumber: newNumber(ptr.Float64(0)),
inputSeries: newSeries(util.Pointer(-30.0)),
expectedNumber: newNumber(util.Pointer(0.0)),
},
{
name: "diff two positive points [1]",
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(40)),
expectedNumber: newNumber(ptr.Float64(10)),
inputSeries: newSeries(util.Pointer(30.0), util.Pointer(40.0)),
expectedNumber: newNumber(util.Pointer(10.0)),
},
{
name: "diff two positive points [2]",
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(20)),
expectedNumber: newNumber(ptr.Float64(-10)),
inputSeries: newSeries(util.Pointer(30.0), util.Pointer(20.0)),
expectedNumber: newNumber(util.Pointer(-10.0)),
},
{
name: "diff two negative points [1]",
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(-40)),
expectedNumber: newNumber(ptr.Float64(-10)),
inputSeries: newSeries(util.Pointer(-30.0), util.Pointer(-40.0)),
expectedNumber: newNumber(util.Pointer(-10.0)),
},
{
name: "diff two negative points [2]",
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(-10)),
expectedNumber: newNumber(ptr.Float64(20)),
inputSeries: newSeries(util.Pointer(-30.0), util.Pointer(-10.0)),
expectedNumber: newNumber(util.Pointer(20.0)),
},
{
name: "diff of one positive and one negative point",
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(-40)),
expectedNumber: newNumber(ptr.Float64(-70)),
inputSeries: newSeries(util.Pointer(30.0), util.Pointer(-40.0)),
expectedNumber: newNumber(util.Pointer(-70.0)),
},
{
name: "diff of one negative and one positive point",
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(40)),
expectedNumber: newNumber(ptr.Float64(70)),
inputSeries: newSeries(util.Pointer(-30.0), util.Pointer(40.0)),
expectedNumber: newNumber(util.Pointer(70.0)),
},
{
name: "diff of three positive points",
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(40), ptr.Float64(50)),
expectedNumber: newNumber(ptr.Float64(20)),
inputSeries: newSeries(util.Pointer(30.0), util.Pointer(40.0), util.Pointer(50.0)),
expectedNumber: newNumber(util.Pointer(20.0)),
},
{
name: "diff of three negative points",
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(-40), ptr.Float64(-50)),
expectedNumber: newNumber(ptr.Float64(-20)),
inputSeries: newSeries(util.Pointer(-30.0), util.Pointer(-40.0), util.Pointer(-50.0)),
expectedNumber: newNumber(util.Pointer(-20.0)),
},
{
name: "diff with only nulls",
@@ -204,53 +204,53 @@ func TestDiffAbsReducer(t *testing.T) {
}{
{
name: "diff_abs of one positive point",
inputSeries: newSeries(ptr.Float64(30)),
expectedNumber: newNumber(ptr.Float64(0)),
inputSeries: newSeries(util.Pointer(30.0)),
expectedNumber: newNumber(util.Pointer(0.0)),
},
{
name: "diff_abs of one negative point",
inputSeries: newSeries(ptr.Float64(-30)),
expectedNumber: newNumber(ptr.Float64(0)),
inputSeries: newSeries(util.Pointer(-30.0)),
expectedNumber: newNumber(util.Pointer(0.0)),
},
{
name: "diff_abs two positive points [1]",
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(40)),
expectedNumber: newNumber(ptr.Float64(10)),
inputSeries: newSeries(util.Pointer(30.0), util.Pointer(40.0)),
expectedNumber: newNumber(util.Pointer(10.0)),
},
{
name: "diff_abs two positive points [2]",
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(20)),
expectedNumber: newNumber(ptr.Float64(10)),
inputSeries: newSeries(util.Pointer(30.0), util.Pointer(20.0)),
expectedNumber: newNumber(util.Pointer(10.0)),
},
{
name: "diff_abs two negative points [1]",
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(-40)),
expectedNumber: newNumber(ptr.Float64(10)),
inputSeries: newSeries(util.Pointer(-30.0), util.Pointer(-40.0)),
expectedNumber: newNumber(util.Pointer(10.0)),
},
{
name: "diff_abs two negative points [2]",
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(-10)),
expectedNumber: newNumber(ptr.Float64(20)),
inputSeries: newSeries(util.Pointer(-30.0), util.Pointer(-10.0)),
expectedNumber: newNumber(util.Pointer(20.0)),
},
{
name: "diff_abs of one positive and one negative point",
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(-40)),
expectedNumber: newNumber(ptr.Float64(70)),
inputSeries: newSeries(util.Pointer(30.0), util.Pointer(-40.0)),
expectedNumber: newNumber(util.Pointer(70.0)),
},
{
name: "diff_abs of one negative and one positive point",
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(40)),
expectedNumber: newNumber(ptr.Float64(70)),
inputSeries: newSeries(util.Pointer(-30.0), util.Pointer(40.0)),
expectedNumber: newNumber(util.Pointer(70.0)),
},
{
name: "diff_abs of three positive points",
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(40), ptr.Float64(50)),
expectedNumber: newNumber(ptr.Float64(20)),
inputSeries: newSeries(util.Pointer(30.0), util.Pointer(40.0), util.Pointer(50.0)),
expectedNumber: newNumber(util.Pointer(20.0)),
},
{
name: "diff_abs of three negative points",
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(-40), ptr.Float64(-50)),
expectedNumber: newNumber(ptr.Float64(20)),
inputSeries: newSeries(util.Pointer(-30.0), util.Pointer(-40.0), util.Pointer(-50.0)),
expectedNumber: newNumber(util.Pointer(20.0)),
},
{
name: "diff_abs with only nulls",
@@ -274,53 +274,53 @@ func TestPercentDiffReducer(t *testing.T) {
}{
{
name: "percent_diff of one positive point",
inputSeries: newSeries(ptr.Float64(30)),
expectedNumber: newNumber(ptr.Float64(0)),
inputSeries: newSeries(util.Pointer(30.0)),
expectedNumber: newNumber(util.Pointer(0.0)),
},
{
name: "percent_diff of one negative point",
inputSeries: newSeries(ptr.Float64(-30)),
expectedNumber: newNumber(ptr.Float64(0)),
inputSeries: newSeries(util.Pointer(-30.0)),
expectedNumber: newNumber(util.Pointer(0.0)),
},
{
name: "percent_diff two positive points [1]",
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(40)),
expectedNumber: newNumber(ptr.Float64(33.33333333333333)),
inputSeries: newSeries(util.Pointer(30.0), util.Pointer(40.0)),
expectedNumber: newNumber(util.Pointer(33.33333333333333)),
},
{
name: "percent_diff two positive points [2]",
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(20)),
expectedNumber: newNumber(ptr.Float64(-33.33333333333333)),
inputSeries: newSeries(util.Pointer(30.0), util.Pointer(20.0)),
expectedNumber: newNumber(util.Pointer(-33.33333333333333)),
},
{
name: "percent_diff two negative points [1]",
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(-40)),
expectedNumber: newNumber(ptr.Float64(-33.33333333333333)),
inputSeries: newSeries(util.Pointer(-30.0), util.Pointer(-40.0)),
expectedNumber: newNumber(util.Pointer(-33.33333333333333)),
},
{
name: "percent_diff two negative points [2]",
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(-10)),
expectedNumber: newNumber(ptr.Float64(66.66666666666666)),
inputSeries: newSeries(util.Pointer(-30.0), util.Pointer(-10.0)),
expectedNumber: newNumber(util.Pointer(66.66666666666666)),
},
{
name: "percent_diff of one positive and one negative point",
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(-40)),
expectedNumber: newNumber(ptr.Float64(-233.33333333333334)),
inputSeries: newSeries(util.Pointer(30.0), util.Pointer(-40.0)),
expectedNumber: newNumber(util.Pointer(-233.33333333333334)),
},
{
name: "percent_diff of one negative and one positive point",
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(40)),
expectedNumber: newNumber(ptr.Float64(233.33333333333334)),
inputSeries: newSeries(util.Pointer(-30.0), util.Pointer(40.0)),
expectedNumber: newNumber(util.Pointer(233.33333333333334)),
},
{
name: "percent_diff of three positive points",
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(40), ptr.Float64(50)),
expectedNumber: newNumber(ptr.Float64(66.66666666666666)),
inputSeries: newSeries(util.Pointer(30.0), util.Pointer(40.0), util.Pointer(50.0)),
expectedNumber: newNumber(util.Pointer(66.66666666666666)),
},
{
name: "percent_diff of three negative points",
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(-40), ptr.Float64(-50)),
expectedNumber: newNumber(ptr.Float64(-66.66666666666666)),
inputSeries: newSeries(util.Pointer(-30.0), util.Pointer(-40.0), util.Pointer(-50.0)),
expectedNumber: newNumber(util.Pointer(-66.66666666666666)),
},
{
name: "percent_diff with only nulls",
@@ -344,53 +344,53 @@ func TestPercentDiffAbsReducer(t *testing.T) {
}{
{
name: "percent_diff_abs of one positive point",
inputSeries: newSeries(ptr.Float64(30)),
expectedNumber: newNumber(ptr.Float64(0)),
inputSeries: newSeries(util.Pointer(30.0)),
expectedNumber: newNumber(util.Pointer(0.0)),
},
{
name: "percent_diff_abs of one negative point",
inputSeries: newSeries(ptr.Float64(-30)),
expectedNumber: newNumber(ptr.Float64(0)),
inputSeries: newSeries(util.Pointer(-30.0)),
expectedNumber: newNumber(util.Pointer(0.0)),
},
{
name: "percent_diff_abs two positive points [1]",
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(40)),
expectedNumber: newNumber(ptr.Float64(33.33333333333333)),
inputSeries: newSeries(util.Pointer(30.0), util.Pointer(40.0)),
expectedNumber: newNumber(util.Pointer(33.33333333333333)),
},
{
name: "percent_diff_abs two positive points [2]",
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(20)),
expectedNumber: newNumber(ptr.Float64(33.33333333333333)),
inputSeries: newSeries(util.Pointer(30.0), util.Pointer(20.0)),
expectedNumber: newNumber(util.Pointer(33.33333333333333)),
},
{
name: "percent_diff_abs two negative points [1]",
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(-40)),
expectedNumber: newNumber(ptr.Float64(33.33333333333333)),
inputSeries: newSeries(util.Pointer(-30.0), util.Pointer(-40.0)),
expectedNumber: newNumber(util.Pointer(33.33333333333333)),
},
{
name: "percent_diff_abs two negative points [2]",
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(-10)),
expectedNumber: newNumber(ptr.Float64(66.66666666666666)),
inputSeries: newSeries(util.Pointer(-30.0), util.Pointer(-10.0)),
expectedNumber: newNumber(util.Pointer(66.66666666666666)),
},
{
name: "percent_diff_abs of one positive and one negative point",
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(-40)),
expectedNumber: newNumber(ptr.Float64(233.33333333333334)),
inputSeries: newSeries(util.Pointer(30.0), util.Pointer(-40.0)),
expectedNumber: newNumber(util.Pointer(233.33333333333334)),
},
{
name: "percent_diff_abs of one negative and one positive point",
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(40)),
expectedNumber: newNumber(ptr.Float64(233.33333333333334)),
inputSeries: newSeries(util.Pointer(-30.0), util.Pointer(40.0)),
expectedNumber: newNumber(util.Pointer(233.33333333333334)),
},
{
name: "percent_diff_abs of three positive points",
inputSeries: newSeries(ptr.Float64(30), ptr.Float64(40), ptr.Float64(50)),
expectedNumber: newNumber(ptr.Float64(66.66666666666666)),
inputSeries: newSeries(util.Pointer(30.0), util.Pointer(40.0), util.Pointer(50.0)),
expectedNumber: newNumber(util.Pointer(66.66666666666666)),
},
{
name: "percent_diff_abs of three negative points",
inputSeries: newSeries(ptr.Float64(-30), ptr.Float64(-40), ptr.Float64(-50)),
expectedNumber: newNumber(ptr.Float64(66.66666666666666)),
inputSeries: newSeries(util.Pointer(-30.0), util.Pointer(-40.0), util.Pointer(-50.0)),
expectedNumber: newNumber(util.Pointer(66.66666666666666)),
},
{
name: "percent_diff_abs with only nulls",
pkg/expr/commands_test.go
+4 -5
View File
@@ -11,7 +11,6 @@ import (
"github.com/grafana/grafana-plugin-sdk-go/data"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
ptr "github.com/xorcare/pointer"
"github.com/grafana/grafana/pkg/expr/mathexp"
"github.com/grafana/grafana/pkg/expr/mathexp/parse"
@@ -105,9 +104,9 @@ func TestReduceExecute(t *testing.T) {
t.Run("should noop if Number", func(t *testing.T) {
var numbers mathexp.Values = []mathexp.Value{
mathexp.GenerateNumber(ptr.Float64(rand.Float64())),
mathexp.GenerateNumber(ptr.Float64(rand.Float64())),
mathexp.GenerateNumber(ptr.Float64(rand.Float64())),
mathexp.GenerateNumber(util.Pointer(rand.Float64())),
mathexp.GenerateNumber(util.Pointer(rand.Float64())),
mathexp.GenerateNumber(util.Pointer(rand.Float64())),
}
vars := map[string]mathexp.Results{
@@ -202,7 +201,7 @@ func TestResampleCommand_Execute(t *testing.T) {
isError: true,
}, {
name: "should return error when input Scalar",
vals: mathexp.NewScalar("test", ptr.Float64(rand.Float64())),
vals: mathexp.NewScalar("test", util.Pointer(rand.Float64())),
isError: true,
},
}