apitech
/
grafana
mirror of https://github.com/grafana/grafana
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Chore: Move away from convey - introduce testify (#32295)

Browse Source 
* Generic OAuth: Prevent adding duplicated users

* Chore: Move away from convey - introduce testify

* Revert commits from another branch

* Fix formatting
pull/32301/head
Dimitris Sotirakis 4 years ago committed by GitHub
parent 66548878fe
commit 95de48261b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 126 additions and 172 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 298
      pkg/tsdb/influxdb/response_parser_test.go

298
pkg/tsdb/influxdb/response_parser_test.go
Unescape View File

@ -6,230 +6,184 @@ import (
"testing"
"github.com/grafana/grafana/pkg/setting"
. "github.com/smartystreets/goconvey/convey"
"github.com/stretchr/testify/require"
)
func TestInfluxdbResponseParser(t *testing.T) {
Convey("Influxdb response parser", t, func() {
Convey("Response parser", func() {
parser := &ResponseParser{}
cfg := setting.NewCfg()
err := cfg.Load(&setting.CommandLineArgs{
HomePath: "../../../",
})
So(err, ShouldBeNil)
response := &Response{
Results: []Result{
{
Series: []Row{
{
Name: "cpu",
Columns: []string{"time", "mean", "sum"},
Tags: map[string]string{"datacenter": "America"},
Values: [][]interface{}{
{json.Number("111"), json.Number("222"), json.Number("333")},
{json.Number("111"), json.Number("222"), json.Number("333")},
{json.Number("111"), json.Number("null"), json.Number("333")},
},
t.Run("Influxdb response parser should parse everything normally", func(t *testing.T) {
parser := &ResponseParser{}
cfg := setting.NewCfg()
err := cfg.Load(&setting.CommandLineArgs{
HomePath: "../../../",
})
require.NoError(t, err)
response := &Response{
Results: []Result{
{
Series: []Row{
{
Name: "cpu",
Columns: []string{"time", "mean", "sum"},
Tags: map[string]string{"datacenter": "America"},
Values: [][]interface{}{
{json.Number("111"), json.Number("222"), json.Number("333")},
{json.Number("111"), json.Number("222"), json.Number("333")},
{json.Number("111"), json.Number("null"), json.Number("333")},
},
},
},
},
}
},
}
query := &Query{}
query := &Query{}
result := parser.Parse(response, query)
result := parser.Parse(response, query)
Convey("can parse all series", func() {
So(len(result.Series), ShouldEqual, 2)
})
require.Len(t, result.Series, 2)
Convey("can parse all points", func() {
So(len(result.Series[0].Points), ShouldEqual, 3)
So(len(result.Series[1].Points), ShouldEqual, 3)
})
require.Len(t, result.Series[0].Points, 3)
require.Len(t, result.Series[1].Points, 3)
Convey("can parse multi row result", func() {
So(result.Series[0].Points[1][0].Float64, ShouldEqual, float64(222))
So(result.Series[1].Points[1][0].Float64, ShouldEqual, float64(333))
})
require.Equal(t, result.Series[0].Points[1][0].Float64, float64(222))
require.Equal(t, result.Series[1].Points[1][0].Float64, float64(333))
Convey("can parse null points", func() {
So(result.Series[0].Points[2][0].Valid, ShouldBeFalse)
})
require.False(t, result.Series[0].Points[2][0].Valid)
Convey("can format series names", func() {
So(result.Series[0].Name, ShouldEqual, "cpu.mean { datacenter: America }")
So(result.Series[1].Name, ShouldEqual, "cpu.sum { datacenter: America }")
})
})
require.Equal(t, result.Series[0].Name, "cpu.mean { datacenter: America }")
require.Equal(t, result.Series[1].Name, "cpu.sum { datacenter: America }")
})
Convey("Response parser with alias", func() {
parser := &ResponseParser{}
response := &Response{
Results: []Result{
{
Series: []Row{
{
Name: "cpu.upc",
Columns: []string{"time", "mean", "sum"},
Tags: map[string]string{
"datacenter": "America",
"dc.region.name": "Northeast",
"cluster-name": "Cluster",
},
Values: [][]interface{}{
{json.Number("111"), json.Number("222"), json.Number("333")},
},
t.Run("Influxdb response parser with alias", func(t *testing.T) {
parser := &ResponseParser{}
response := &Response{
Results: []Result{
{
Series: []Row{
{
Name: "cpu.upc",
Columns: []string{"time", "mean", "sum"},
Tags: map[string]string{
"datacenter": "America",
"dc.region.name": "Northeast",
"cluster-name": "Cluster",
},
Values: [][]interface{}{
{json.Number("111"), json.Number("222"), json.Number("333")},
},
},
},
},
}
},
}
Convey("$ alias", func() {
Convey("simple alias", func() {
query := &Query{Alias: "series alias"}
result := parser.Parse(response, query)
query := &Query{Alias: "series alias"}
result := parser.Parse(response, query)
So(result.Series[0].Name, ShouldEqual, "series alias")
})
require.Equal(t, result.Series[0].Name, "series alias")
Convey("measurement alias", func() {
query := &Query{Alias: "alias $m $measurement", Measurement: "10m"}
result := parser.Parse(response, query)
query = &Query{Alias: "alias $m $measurement", Measurement: "10m"}
result = parser.Parse(response, query)
So(result.Series[0].Name, ShouldEqual, "alias 10m 10m")
})
require.Equal(t, result.Series[0].Name, "alias 10m 10m")
Convey("column alias", func() {
query := &Query{Alias: "alias $col", Measurement: "10m"}
result := parser.Parse(response, query)
query = &Query{Alias: "alias $col", Measurement: "10m"}
result = parser.Parse(response, query)
So(result.Series[0].Name, ShouldEqual, "alias mean")
So(result.Series[1].Name, ShouldEqual, "alias sum")
})
require.Equal(t, result.Series[0].Name, "alias mean")
require.Equal(t, result.Series[1].Name, "alias sum")
Convey("tag alias", func() {
query := &Query{Alias: "alias $tag_datacenter"}
result := parser.Parse(response, query)
query = &Query{Alias: "alias $tag_datacenter"}
result = parser.Parse(response, query)
So(result.Series[0].Name, ShouldEqual, "alias America")
})
require.Equal(t, result.Series[0].Name, "alias America")
Convey("segment alias", func() {
query := &Query{Alias: "alias $1"}
result := parser.Parse(response, query)
query = &Query{Alias: "alias $1"}
result = parser.Parse(response, query)
So(result.Series[0].Name, ShouldEqual, "alias upc")
})
require.Equal(t, result.Series[0].Name, "alias upc")
Convey("segment position out of bound", func() {
query := &Query{Alias: "alias $5"}
result := parser.Parse(response, query)
query = &Query{Alias: "alias $5"}
result = parser.Parse(response, query)
So(result.Series[0].Name, ShouldEqual, "alias $5")
})
})
require.Equal(t, result.Series[0].Name, "alias $5")
Convey("[[]] alias", func() {
Convey("simple alias", func() {
query := &Query{Alias: "series alias"}
result := parser.Parse(response, query)
query = &Query{Alias: "series alias"}
result = parser.Parse(response, query)
So(result.Series[0].Name, ShouldEqual, "series alias")
})
require.Equal(t, result.Series[0].Name, "series alias")
Convey("measurement alias", func() {
query := &Query{Alias: "alias [[m]] [[measurement]]", Measurement: "10m"}
result := parser.Parse(response, query)
query = &Query{Alias: "alias [[m]] [[measurement]]", Measurement: "10m"}
result = parser.Parse(response, query)
So(result.Series[0].Name, ShouldEqual, "alias 10m 10m")
})
require.Equal(t, result.Series[0].Name, "alias 10m 10m")
Convey("column alias", func() {
query := &Query{Alias: "alias [[col]]", Measurement: "10m"}
result := parser.Parse(response, query)
query = &Query{Alias: "alias [[col]]", Measurement: "10m"}
result = parser.Parse(response, query)
So(result.Series[0].Name, ShouldEqual, "alias mean")
So(result.Series[1].Name, ShouldEqual, "alias sum")
})
require.Equal(t, result.Series[0].Name, "alias mean")
require.Equal(t, result.Series[1].Name, "alias sum")
Convey("tag alias", func() {
query := &Query{Alias: "alias [[tag_datacenter]]"}
result := parser.Parse(response, query)
query = &Query{Alias: "alias [[tag_datacenter]]"}
result = parser.Parse(response, query)
So(result.Series[0].Name, ShouldEqual, "alias America")
})
require.Equal(t, result.Series[0].Name, "alias America")
Convey("tag alias with periods", func() {
query := &Query{Alias: "alias [[tag_dc.region.name]]"}
result := parser.Parse(response, query)
query = &Query{Alias: "alias [[tag_dc.region.name]]"}
result = parser.Parse(response, query)
So(result.Series[0].Name, ShouldEqual, "alias Northeast")
})
require.Equal(t, result.Series[0].Name, "alias Northeast")
Convey("tag alias with hyphens", func() {
query := &Query{Alias: "alias [[tag_cluster-name]]"}
result := parser.Parse(response, query)
query = &Query{Alias: "alias [[tag_cluster-name]]"}
result = parser.Parse(response, query)
So(result.Series[0].Name, ShouldEqual, "alias Cluster")
})
})
})
require.Equal(t, result.Series[0].Name, "alias Cluster")
})
t.Run("Influxdb response parser with errors", func(t *testing.T) {
parser := &ResponseParser{}
Convey("Response parser with errors", func() {
parser := &ResponseParser{}
cfg := setting.NewCfg()
err := cfg.Load(&setting.CommandLineArgs{
HomePath: "../../../",
})
So(err, ShouldBeNil)
response := &Response{
Results: []Result{
{
Series: []Row{
{
Name: "cpu",
Columns: []string{"time", "mean", "sum"},
Tags: map[string]string{"datacenter": "America"},
Values: [][]interface{}{
{json.Number("111"), json.Number("222"), json.Number("333")},
{json.Number("111"), json.Number("222"), json.Number("333")},
{json.Number("111"), json.Number("null"), json.Number("333")},
},
cfg := setting.NewCfg()
err := cfg.Load(&setting.CommandLineArgs{
HomePath: "../../../",
})
require.Nil(t, err)
response := &Response{
Results: []Result{
{
Series: []Row{
{
Name: "cpu",
Columns: []string{"time", "mean", "sum"},
Tags: map[string]string{"datacenter": "America"},
Values: [][]interface{}{
{json.Number("111"), json.Number("222"), json.Number("333")},
{json.Number("111"), json.Number("222"), json.Number("333")},
{json.Number("111"), json.Number("null"), json.Number("333")},
},
},
},
{
Err: fmt.Errorf("query-timeout limit exceeded"),
},
},
}
{
Err: fmt.Errorf("query-timeout limit exceeded"),
},
},
}
query := &Query{}
query := &Query{}
result := parser.Parse(response, query)
result := parser.Parse(response, query)
Convey("can parse all series", func() {
So(len(result.Series), ShouldEqual, 2)
})
require.Len(t, result.Series, 2)
Convey("can parse all points", func() {
So(len(result.Series[0].Points), ShouldEqual, 3)
So(len(result.Series[1].Points), ShouldEqual, 3)
})
require.Len(t, result.Series[0].Points, 3)
require.Len(t, result.Series[1].Points, 3)
Convey("can parse errors ", func() {
So(result.Error, ShouldNotBeNil)
So(result.Error.Error(), ShouldEqual, "query-timeout limit exceeded")
})
})
require.Error(t, result.Error)
require.Equal(t, result.Error.Error(), "query-timeout limit exceeded")
})
}

Write Preview
Loading…
Cancel
Save