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

Cloudwatch: Convert go convey tests to standard test library (#28003)

Browse Source 
* Cloudwatch: Convert go convey tests to standard test library

* Fix tests

Signed-off-by: Arve Knudsen <arve.knudsen@gmail.com>

Co-authored-by: Arve Knudsen <arve.knudsen@gmail.com>
pull/28014/head
Matheus Alcantara 5 years ago committed by GitHub
parent 89ebab6377
commit 7d7e727f22
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 898 additions and 966 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. 109
      pkg/tsdb/cloudwatch/cloudwatch_query_test.go
  2. 64
      pkg/tsdb/cloudwatch/metric_data_query_builder_test.go
  3. 63
      pkg/tsdb/cloudwatch/query_transformer_test.go
  4. 144
      pkg/tsdb/cloudwatch/request_parser_test.go
  5. 92
      pkg/tsdb/cloudwatch/response_parser_test.go

109
pkg/tsdb/cloudwatch/cloudwatch_query_test.go
Unescape View File

@ -3,12 +3,11 @@ package cloudwatch
import (
"testing"
. "github.com/smartystreets/goconvey/convey"
"github.com/stretchr/testify/assert"
)
func TestCloudWatchQuery(t *testing.T) {
Convey("TestCloudWatchQuery", t, func() {
Convey("and SEARCH(someexpression) was specified in the query editor", func() {
t.Run("SEARCH(someexpression) was specified in the query editor", func(t *testing.T) {
query := &cloudWatchQuery{
RefId: "A",
Region: "us-east-1",
@ -18,16 +17,11 @@ func TestCloudWatchQuery(t *testing.T) {
Id: "id1",
}
Convey("it is a search expression", func() {
So(query.isSearchExpression(), ShouldBeTrue)
assert.True(t, query.isSearchExpression(), "Expected a search expression")
assert.False(t, query.isMathExpression(), "Expected not math expression")
})
Convey("it is not math expressions", func() {
So(query.isMathExpression(), ShouldBeFalse)
})
})
Convey("and no expression, no multi dimension key values and no * was used", func() {
t.Run("No expression, no multi dimension key values and no * was used", func(t *testing.T) {
query := &cloudWatchQuery{
RefId: "A",
Region: "us-east-1",
@ -41,16 +35,11 @@ func TestCloudWatchQuery(t *testing.T) {
},
}
Convey("it is not a search expression", func() {
So(query.isSearchExpression(), ShouldBeFalse)
})
Convey("it is not math expressions", func() {
So(query.isMathExpression(), ShouldBeFalse)
})
assert.False(t, query.isSearchExpression(), "Expected not a search expression")
assert.False(t, query.isMathExpression(), "Expected not math expressions")
})
Convey("and no expression but multi dimension key values exist", func() {
t.Run("No expression but multi dimension key values exist", func(t *testing.T) {
query := &cloudWatchQuery{
RefId: "A",
Region: "us-east-1",
@ -63,16 +52,11 @@ func TestCloudWatchQuery(t *testing.T) {
},
}
Convey("it is a search expression", func() {
So(query.isSearchExpression(), ShouldBeTrue)
})
Convey("it is not math expressions", func() {
So(query.isMathExpression(), ShouldBeFalse)
})
assert.True(t, query.isSearchExpression(), "Expected a search expression")
assert.False(t, query.isMathExpression(), "Expected not math expressions")
})
Convey("and no expression but dimension values has *", func() {
t.Run("No expression but dimension values has *", func(t *testing.T) {
query := &cloudWatchQuery{
RefId: "A",
Region: "us-east-1",
@ -86,16 +70,11 @@ func TestCloudWatchQuery(t *testing.T) {
},
}
Convey("it is not a search expression", func() {
So(query.isSearchExpression(), ShouldBeTrue)
})
Convey("it is not math expressions", func() {
So(query.isMathExpression(), ShouldBeFalse)
})
assert.True(t, query.isSearchExpression(), "Expected a search expression")
assert.False(t, query.isMathExpression(), "Expected not math expression")
})
Convey("and query has a multi-valued dimension", func() {
t.Run("Query has a multi-valued dimension", func(t *testing.T) {
query := &cloudWatchQuery{
RefId: "A",
Region: "us-east-1",
@ -109,16 +88,11 @@ func TestCloudWatchQuery(t *testing.T) {
},
}
Convey("it is a search expression", func() {
So(query.isSearchExpression(), ShouldBeTrue)
assert.True(t, query.isSearchExpression(), "Expected a search expression")
assert.True(t, query.isMultiValuedDimensionExpression(), "Expected a multi-valued dimension expression")
})
Convey("it is a multi-valued dimension expression", func() {
So(query.isMultiValuedDimensionExpression(), ShouldBeTrue)
})
})
Convey("and no dimensions were added", func() {
t.Run("No dimensions were added", func(t *testing.T) {
query := &cloudWatchQuery{
RefId: "A",
Region: "us-east-1",
@ -129,38 +103,22 @@ func TestCloudWatchQuery(t *testing.T) {
MatchExact: false,
Dimensions: make(map[string][]string),
}
Convey("and match exact is false", func() {
t.Run("Match exact is false", func(t *testing.T) {
query.MatchExact = false
Convey("it is a search expression", func() {
So(query.isSearchExpression(), ShouldBeTrue)
assert.True(t, query.isSearchExpression(), "Expected a search expression")
assert.False(t, query.isMathExpression(), "Expected not math expression")
assert.False(t, query.isMetricStat(), "Expected not metric stat")
})
Convey("it is not math expressions", func() {
So(query.isMathExpression(), ShouldBeFalse)
})
Convey("it is not metric stat", func() {
So(query.isMetricStat(), ShouldBeFalse)
})
})
Convey("and match exact is true", func() {
t.Run("Match exact is true", func(t *testing.T) {
query.MatchExact = true
Convey("it is a search expression", func() {
So(query.isSearchExpression(), ShouldBeFalse)
assert.False(t, query.isSearchExpression(), "Exxpected not search expression")
assert.False(t, query.isMathExpression(), "Expected not math expression")
assert.True(t, query.isMetricStat(), "Expected a metric stat")
})
Convey("it is not math expressions", func() {
So(query.isMathExpression(), ShouldBeFalse)
})
Convey("it is a metric stat", func() {
So(query.isMetricStat(), ShouldBeTrue)
})
})
})
Convey("and match exact is", func() {
t.Run("Match exact is", func(t *testing.T) {
query := &cloudWatchQuery{
RefId: "A",
Region: "us-east-1",
@ -174,17 +132,8 @@ func TestCloudWatchQuery(t *testing.T) {
},
}
Convey("it is a search expression", func() {
So(query.isSearchExpression(), ShouldBeTrue)
})
Convey("it is not math expressions", func() {
So(query.isMathExpression(), ShouldBeFalse)
})
Convey("it is not metric stat", func() {
So(query.isMetricStat(), ShouldBeFalse)
})
})
assert.True(t, query.isSearchExpression(), "Expected search expression")
assert.False(t, query.isMathExpression(), "Expected not math expression")
assert.False(t, query.isMetricStat(), "Expected not metric stat")
})
}

64
pkg/tsdb/cloudwatch/metric_data_query_builder_test.go
Unescape View File

@ -3,15 +3,14 @@ package cloudwatch
import (
"testing"
. "github.com/smartystreets/goconvey/convey"
"github.com/stretchr/testify/assert"
)
func TestMetricDataQueryBuilder(t *testing.T) {
Convey("TestMetricDataQueryBuilder", t, func() {
Convey("buildSearchExpression", func() {
Convey("and query should be matched exact", func() {
matchExact := true
Convey("and query has three dimension values for a given dimension key", func() {
func TestMetricDataQueryBuilder_buildSearchExpression(t *testing.T) {
t.Run("Query should be matched exact", func(t *testing.T) {
const matchExact = true
t.Run("Query has three dimension values for a given dimension key", func(t *testing.T) {
query := &cloudWatchQuery{
Namespace: "AWS/EC2",
MetricName: "CPUUtilization",
@ -24,10 +23,10 @@ func TestMetricDataQueryBuilder(t *testing.T) {
}
res := buildSearchExpression(query, "Average")
So(res, ShouldEqual, `REMOVE_EMPTY(SEARCH('{AWS/EC2,"LoadBalancer"} MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3")', 'Average', 300))`)
assert.Equal(t, `REMOVE_EMPTY(SEARCH('{AWS/EC2,"LoadBalancer"} MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3")', 'Average', 300))`, res)
})
Convey("and query has three dimension values for two given dimension keys", func() {
t.Run("Query has three dimension values for two given dimension keys", func(t *testing.T) {
query := &cloudWatchQuery{
Namespace: "AWS/EC2",
MetricName: "CPUUtilization",
@ -41,10 +40,10 @@ func TestMetricDataQueryBuilder(t *testing.T) {
}
res := buildSearchExpression(query, "Average")
So(res, ShouldEqual, `REMOVE_EMPTY(SEARCH('{AWS/EC2,"InstanceId","LoadBalancer"} MetricName="CPUUtilization" "InstanceId"=("i-123" OR "i-456" OR "i-789") "LoadBalancer"=("lb1" OR "lb2" OR "lb3")', 'Average', 300))`)
assert.Equal(t, `REMOVE_EMPTY(SEARCH('{AWS/EC2,"InstanceId","LoadBalancer"} MetricName="CPUUtilization" "InstanceId"=("i-123" OR "i-456" OR "i-789") "LoadBalancer"=("lb1" OR "lb2" OR "lb3")', 'Average', 300))`, res)
})
Convey("and no OR operator was added if a star was used for dimension value", func() {
t.Run("No OR operator was added if a star was used for dimension value", func(t *testing.T) {
query := &cloudWatchQuery{
Namespace: "AWS/EC2",
MetricName: "CPUUtilization",
@ -57,10 +56,10 @@ func TestMetricDataQueryBuilder(t *testing.T) {
}
res := buildSearchExpression(query, "Average")
So(res, ShouldNotContainSubstring, "OR")
assert.NotContains(t, res, "OR")
})
Convey("and query has one dimension key with a * value", func() {
t.Run("Query has one dimension key with a * value", func(t *testing.T) {
query := &cloudWatchQuery{
Namespace: "AWS/EC2",
MetricName: "CPUUtilization",
@ -73,10 +72,10 @@ func TestMetricDataQueryBuilder(t *testing.T) {
}
res := buildSearchExpression(query, "Average")
So(res, ShouldEqual, `REMOVE_EMPTY(SEARCH('{AWS/EC2,"LoadBalancer"} MetricName="CPUUtilization"', 'Average', 300))`)
assert.Equal(t, res, `REMOVE_EMPTY(SEARCH('{AWS/EC2,"LoadBalancer"} MetricName="CPUUtilization"', 'Average', 300))`)
})
Convey("and query has three dimension values for two given dimension keys, and one value is a star", func() {
t.Run("Query has three dimension values for two given dimension keys, and one value is a star", func(t *testing.T) {
query := &cloudWatchQuery{
Namespace: "AWS/EC2",
MetricName: "CPUUtilization",
@ -90,10 +89,10 @@ func TestMetricDataQueryBuilder(t *testing.T) {
}
res := buildSearchExpression(query, "Average")
So(res, ShouldEqual, `REMOVE_EMPTY(SEARCH('{AWS/EC2,"InstanceId","LoadBalancer"} MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3")', 'Average', 300))`)
assert.Equal(t, `REMOVE_EMPTY(SEARCH('{AWS/EC2,"InstanceId","LoadBalancer"} MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3")', 'Average', 300))`, res)
})
Convey("and query has a dimension key with a space", func() {
t.Run("Query has a dimension key with a space", func(t *testing.T) {
query := &cloudWatchQuery{
Namespace: "AWS/Kafka",
MetricName: "CpuUser",
@ -106,13 +105,14 @@ func TestMetricDataQueryBuilder(t *testing.T) {
}
res := buildSearchExpression(query, "Average")
So(res, ShouldEqual, `REMOVE_EMPTY(SEARCH('{AWS/Kafka,"Cluster Name"} MetricName="CpuUser" "Cluster Name"="dev-cluster"', 'Average', 300))`)
assert.Equal(t, `REMOVE_EMPTY(SEARCH('{AWS/Kafka,"Cluster Name"} MetricName="CpuUser" "Cluster Name"="dev-cluster"', 'Average', 300))`, res)
})
})
Convey("and query should not be matched exact", func() {
matchExact := false
Convey("and query has three dimension values for a given dimension key", func() {
t.Run("Query should not be matched exact", func(t *testing.T) {
const matchExact = false
t.Run("Query has three dimension values for a given dimension key", func(t *testing.T) {
query := &cloudWatchQuery{
Namespace: "AWS/EC2",
MetricName: "CPUUtilization",
@ -125,10 +125,10 @@ func TestMetricDataQueryBuilder(t *testing.T) {
}
res := buildSearchExpression(query, "Average")
So(res, ShouldEqual, `REMOVE_EMPTY(SEARCH('Namespace="AWS/EC2" MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3")', 'Average', 300))`)
assert.Equal(t, `REMOVE_EMPTY(SEARCH('Namespace="AWS/EC2" MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3")', 'Average', 300))`, res)
})
Convey("and query has three dimension values for two given dimension keys", func() {
t.Run("Query has three dimension values for two given dimension keys", func(t *testing.T) {
query := &cloudWatchQuery{
Namespace: "AWS/EC2",
MetricName: "CPUUtilization",
@ -142,10 +142,10 @@ func TestMetricDataQueryBuilder(t *testing.T) {
}
res := buildSearchExpression(query, "Average")
So(res, ShouldEqual, `REMOVE_EMPTY(SEARCH('Namespace="AWS/EC2" MetricName="CPUUtilization" "InstanceId"=("i-123" OR "i-456" OR "i-789") "LoadBalancer"=("lb1" OR "lb2" OR "lb3")', 'Average', 300))`)
assert.Equal(t, `REMOVE_EMPTY(SEARCH('Namespace="AWS/EC2" MetricName="CPUUtilization" "InstanceId"=("i-123" OR "i-456" OR "i-789") "LoadBalancer"=("lb1" OR "lb2" OR "lb3")', 'Average', 300))`, res)
})
Convey("and query has one dimension key with a * value", func() {
t.Run("Query has one dimension key with a * value", func(t *testing.T) {
query := &cloudWatchQuery{
Namespace: "AWS/EC2",
MetricName: "CPUUtilization",
@ -158,10 +158,10 @@ func TestMetricDataQueryBuilder(t *testing.T) {
}
res := buildSearchExpression(query, "Average")
So(res, ShouldEqual, `REMOVE_EMPTY(SEARCH('Namespace="AWS/EC2" MetricName="CPUUtilization" "LoadBalancer"', 'Average', 300))`)
assert.Equal(t, `REMOVE_EMPTY(SEARCH('Namespace="AWS/EC2" MetricName="CPUUtilization" "LoadBalancer"', 'Average', 300))`, res)
})
Convey("and query has three dimension values for two given dimension keys, and one value is a star", func() {
t.Run("query has three dimension values for two given dimension keys, and one value is a star", func(t *testing.T) {
query := &cloudWatchQuery{
Namespace: "AWS/EC2",
MetricName: "CPUUtilization",
@ -175,12 +175,11 @@ func TestMetricDataQueryBuilder(t *testing.T) {
}
res := buildSearchExpression(query, "Average")
So(res, ShouldEqual, `REMOVE_EMPTY(SEARCH('Namespace="AWS/EC2" MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3") "InstanceId"', 'Average', 300))`)
})
assert.Equal(t, `REMOVE_EMPTY(SEARCH('Namespace="AWS/EC2" MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3") "InstanceId"', 'Average', 300))`, res)
})
})
Convey("and query has invalid characters in dimension values", func() {
t.Run("Query has invalid characters in dimension values", func(t *testing.T) {
query := &cloudWatchQuery{
Namespace: "AWS/EC2",
MetricName: "CPUUtilization",
@ -193,9 +192,6 @@ func TestMetricDataQueryBuilder(t *testing.T) {
}
res := buildSearchExpression(query, "Average")
Convey("it should escape double quotes", func() {
So(res, ShouldContainSubstring, `lb4\"\"`)
})
})
assert.Contains(t, res, `lb4\"\"`, "Expected escape double quotes")
})
}

63
pkg/tsdb/cloudwatch/query_transformer_test.go
Unescape View File

@ -4,14 +4,13 @@ import (
"testing"
"github.com/aws/aws-sdk-go/aws"
. "github.com/smartystreets/goconvey/convey"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestQueryTransformer(t *testing.T) {
Convey("TestQueryTransformer", t, func() {
Convey("when transforming queries", func() {
executor := newExecutor()
Convey("one cloudwatchQuery is generated when its request query has one stat", func() {
t.Run("One cloudwatchQuery is generated when its request query has one stat", func(t *testing.T) {
requestQueries := []*requestQuery{
{
RefId: "D",
@ -25,11 +24,11 @@ func TestQueryTransformer(t *testing.T) {
}
res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
So(err, ShouldBeNil)
So(len(res), ShouldEqual, 1)
require.NoError(t, err)
assert.Len(t, res, 1)
})
Convey("two cloudwatchQuery is generated when there's two stats", func() {
t.Run("Two cloudwatchQuery is generated when there's two stats", func(t *testing.T) {
requestQueries := []*requestQuery{
{
RefId: "D",
@ -43,11 +42,10 @@ func TestQueryTransformer(t *testing.T) {
}
res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
So(err, ShouldBeNil)
So(len(res), ShouldEqual, 2)
require.NoError(t, err)
assert.Len(t, res, 2)
})
Convey("and id is given by user", func() {
Convey("that id will be used in the cloudwatch query", func() {
t.Run("id is given by user that will be used in the cloudwatch query", func(t *testing.T) {
requestQueries := []*requestQuery{
{
RefId: "D",
@ -61,14 +59,13 @@ func TestQueryTransformer(t *testing.T) {
}
res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
So(err, ShouldBeNil)
So(len(res), ShouldEqual, 1)
So(res, ShouldContainKey, "myid")
})
require.Nil(t, err)
assert.Equal(t, len(res), 1)
assert.Contains(t, res, "myid")
})
Convey("and id is not given by user", func() {
Convey("id will be generated based on ref id if query only has one stat", func() {
t.Run("ID is not given by user", func(t *testing.T) {
t.Run("ID will be generated based on ref ID if query only has one stat", func(t *testing.T) {
requestQueries := []*requestQuery{
{
RefId: "D",
@ -82,12 +79,12 @@ func TestQueryTransformer(t *testing.T) {
}
res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
So(err, ShouldBeNil)
So(len(res), ShouldEqual, 1)
So(res, ShouldContainKey, "queryD")
require.NoError(t, err)
assert.Len(t, res, 1)
assert.Contains(t, res, "queryD")
})
Convey("id will be generated based on ref and stat name if query has two stats", func() {
t.Run("ID will be generated based on ref and stat name if query has two stats", func(t *testing.T) {
requestQueries := []*requestQuery{
{
RefId: "D",
@ -101,14 +98,14 @@ func TestQueryTransformer(t *testing.T) {
}
res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
So(err, ShouldBeNil)
So(len(res), ShouldEqual, 2)
So(res, ShouldContainKey, "queryD_Sum")
So(res, ShouldContainKey, "queryD_Average")
require.NoError(t, err)
assert.Len(t, res, 2)
assert.Contains(t, res, "queryD_Sum")
assert.Contains(t, res, "queryD_Average")
})
})
Convey("dot should be removed when query has more than one stat and one of them is a percentile", func() {
t.Run("dot should be removed when query has more than one stat and one of them is a percentile", func(t *testing.T) {
requestQueries := []*requestQuery{
{
RefId: "D",
@ -122,12 +119,12 @@ func TestQueryTransformer(t *testing.T) {
}
res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
So(err, ShouldBeNil)
So(len(res), ShouldEqual, 2)
So(res, ShouldContainKey, "queryD_p46_32")
require.NoError(t, err)
assert.Len(t, res, 2)
assert.Contains(t, res, "queryD_p46_32")
})
Convey("should return an error if two queries have the same id", func() {
t.Run("should return an error if two queries have the same id", func(t *testing.T) {
requestQueries := []*requestQuery{
{
RefId: "D",
@ -150,9 +147,7 @@ func TestQueryTransformer(t *testing.T) {
}
res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
So(res, ShouldBeNil)
So(err, ShouldNotBeNil)
})
})
require.Nil(t, res)
assert.Error(t, err)
})
}

144
pkg/tsdb/cloudwatch/request_parser_test.go
Unescape View File

@ -6,18 +6,18 @@ import (
"github.com/grafana/grafana/pkg/components/simplejson"
"github.com/grafana/grafana/pkg/tsdb"
. "github.com/smartystreets/goconvey/convey"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestRequestParser(t *testing.T) {
Convey("TestRequestParser", t, func() {
timeRange := tsdb.NewTimeRange("now-1h", "now-2h")
from, err := timeRange.ParseFrom()
So(err, ShouldBeNil)
require.NoError(t, err)
to, err := timeRange.ParseTo()
So(err, ShouldBeNil)
Convey("when parsing query editor row json", func() {
Convey("using new dimensions structure", func() {
require.NoError(t, err)
t.Run("New dimensions structure", func(t *testing.T) {
query := simplejson.NewFromAny(map[string]interface{}{
"refId": "ref1",
"region": "us-east-1",
@ -35,24 +35,24 @@ func TestRequestParser(t *testing.T) {
})
res, err := parseRequestQuery(query, "ref1", from, to)
So(err, ShouldBeNil)
So(res.Region, ShouldEqual, "us-east-1")
So(res.RefId, ShouldEqual, "ref1")
So(res.Namespace, ShouldEqual, "ec2")
So(res.MetricName, ShouldEqual, "CPUUtilization")
So(res.Id, ShouldEqual, "")
So(res.Expression, ShouldEqual, "")
So(res.Period, ShouldEqual, 600)
So(res.ReturnData, ShouldEqual, true)
So(len(res.Dimensions), ShouldEqual, 2)
So(len(res.Dimensions["InstanceId"]), ShouldEqual, 1)
So(len(res.Dimensions["InstanceType"]), ShouldEqual, 2)
So(res.Dimensions["InstanceType"][1], ShouldEqual, "test3")
So(len(res.Statistics), ShouldEqual, 1)
So(*res.Statistics[0], ShouldEqual, "Average")
})
Convey("using old dimensions structure (backwards compatibility)", func() {
require.NoError(t, err)
assert.Equal(t, "us-east-1", res.Region)
assert.Equal(t, "ref1", res.RefId)
assert.Equal(t, "ec2", res.Namespace)
assert.Equal(t, "CPUUtilization", res.MetricName)
assert.Empty(t, res.Id)
assert.Empty(t, res.Expression)
assert.Equal(t, 600, res.Period)
assert.True(t, res.ReturnData)
assert.Len(t, res.Dimensions, 2)
assert.Len(t, res.Dimensions["InstanceId"], 1)
assert.Len(t, res.Dimensions["InstanceType"], 2)
assert.Equal(t, "test3", res.Dimensions["InstanceType"][1])
assert.Len(t, res.Statistics, 1)
assert.Equal(t, "Average", *res.Statistics[0])
})
t.Run("Old dimensions structure (backwards compatibility)", func(t *testing.T) {
query := simplejson.NewFromAny(map[string]interface{}{
"refId": "ref1",
"region": "us-east-1",
@ -70,23 +70,23 @@ func TestRequestParser(t *testing.T) {
})
res, err := parseRequestQuery(query, "ref1", from, to)
So(err, ShouldBeNil)
So(res.Region, ShouldEqual, "us-east-1")
So(res.RefId, ShouldEqual, "ref1")
So(res.Namespace, ShouldEqual, "ec2")
So(res.MetricName, ShouldEqual, "CPUUtilization")
So(res.Id, ShouldEqual, "")
So(res.Expression, ShouldEqual, "")
So(res.Period, ShouldEqual, 600)
So(res.ReturnData, ShouldEqual, true)
So(len(res.Dimensions), ShouldEqual, 2)
So(len(res.Dimensions["InstanceId"]), ShouldEqual, 1)
So(len(res.Dimensions["InstanceType"]), ShouldEqual, 1)
So(res.Dimensions["InstanceType"][0], ShouldEqual, "test2")
So(*res.Statistics[0], ShouldEqual, "Average")
})
Convey("period defined in the editor by the user is being used", func() {
require.NoError(t, err)
assert.Equal(t, "us-east-1", res.Region)
assert.Equal(t, "ref1", res.RefId)
assert.Equal(t, "ec2", res.Namespace)
assert.Equal(t, "CPUUtilization", res.MetricName)
assert.Empty(t, res.Id)
assert.Empty(t, res.Expression)
assert.Equal(t, 600, res.Period)
assert.True(t, res.ReturnData)
assert.Len(t, res.Dimensions, 2)
assert.Len(t, res.Dimensions["InstanceId"], 1)
assert.Len(t, res.Dimensions["InstanceType"], 1)
assert.Equal(t, "test2", res.Dimensions["InstanceType"][0])
assert.Equal(t, "Average", *res.Statistics[0])
})
t.Run("Period defined in the editor by the user is being used when time range is short", func(t *testing.T) {
query := simplejson.NewFromAny(map[string]interface{}{
"refId": "ref1",
"region": "us-east-1",
@ -101,21 +101,19 @@ func TestRequestParser(t *testing.T) {
"statistics": []interface{}{"Average"},
"hide": false,
})
Convey("when time range is short", func() {
query.Set("period", "900")
timeRange := tsdb.NewTimeRange("now-1h", "now-2h")
from, err := timeRange.ParseFrom()
So(err, ShouldBeNil)
require.NoError(t, err)
to, err := timeRange.ParseTo()
So(err, ShouldBeNil)
require.NoError(t, err)
res, err := parseRequestQuery(query, "ref1", from, to)
So(err, ShouldBeNil)
So(res.Period, ShouldEqual, 900)
})
require.NoError(t, err)
assert.Equal(t, 900, res.Period)
})
Convey("period is parsed correctly if not defined by user", func() {
t.Run("Period is parsed correctly if not defined by user", func(t *testing.T) {
query := simplejson.NewFromAny(map[string]interface{}{
"refId": "ref1",
"region": "us-east-1",
@ -132,85 +130,83 @@ func TestRequestParser(t *testing.T) {
"period": "auto",
})
Convey("when time range is 5 minutes", func() {
t.Run("Time range is 5 minutes", func(t *testing.T) {
query.Set("period", "auto")
to := time.Now()
from := to.Local().Add(time.Minute * time.Duration(5))
res, err := parseRequestQuery(query, "ref1", from, to)
So(err, ShouldBeNil)
So(res.Period, ShouldEqual, 60)
require.NoError(t, err)
assert.Equal(t, 60, res.Period)
})
Convey("when time range is 1 day", func() {
t.Run("Time range is 1 day", func(t *testing.T) {
query.Set("period", "auto")
to := time.Now()
from := to.AddDate(0, 0, -1)
res, err := parseRequestQuery(query, "ref1", from, to)
So(err, ShouldBeNil)
So(res.Period, ShouldEqual, 60)
require.NoError(t, err)
assert.Equal(t, 60, res.Period)
})
Convey("when time range is 2 days", func() {
t.Run("Time range is 2 days", func(t *testing.T) {
query.Set("period", "auto")
to := time.Now()
from := to.AddDate(0, 0, -2)
res, err := parseRequestQuery(query, "ref1", from, to)
So(err, ShouldBeNil)
So(res.Period, ShouldEqual, 300)
require.NoError(t, err)
assert.Equal(t, 300, res.Period)
})
Convey("when time range is 7 days", func() {
t.Run("Time range is 7 days", func(t *testing.T) {
query.Set("period", "auto")
to := time.Now()
from := to.AddDate(0, 0, -7)
res, err := parseRequestQuery(query, "ref1", from, to)
So(err, ShouldBeNil)
So(res.Period, ShouldEqual, 900)
require.NoError(t, err)
assert.Equal(t, 900, res.Period)
})
Convey("when time range is 30 days", func() {
t.Run("Time range is 30 days", func(t *testing.T) {
query.Set("period", "auto")
to := time.Now()
from := to.AddDate(0, 0, -30)
res, err := parseRequestQuery(query, "ref1", from, to)
So(err, ShouldBeNil)
So(res.Period, ShouldEqual, 3600)
require.NoError(t, err)
assert.Equal(t, 3600, res.Period)
})
Convey("when time range is 90 days", func() {
t.Run("Time range is 90 days", func(t *testing.T) {
query.Set("period", "auto")
to := time.Now()
from := to.AddDate(0, 0, -90)
res, err := parseRequestQuery(query, "ref1", from, to)
So(err, ShouldBeNil)
So(res.Period, ShouldEqual, 21600)
require.NoError(t, err)
assert.Equal(t, 21600, res.Period)
})
Convey("when time range is 1 year", func() {
t.Run("Time range is 1 year", func(t *testing.T) {
query.Set("period", "auto")
to := time.Now()
from := to.AddDate(-1, 0, 0)
res, err := parseRequestQuery(query, "ref1", from, to)
So(err, ShouldBeNil)
So(res.Period, ShouldEqual, 21600)
require.Nil(t, err)
assert.Equal(t, res.Period, 21600)
})
Convey("when time range is 2 years", func() {
t.Run("Time range is 2 years", func(t *testing.T) {
query.Set("period", "auto")
to := time.Now()
from := to.AddDate(-2, 0, 0)
res, err := parseRequestQuery(query, "ref1", from, to)
So(err, ShouldBeNil)
So(res.Period, ShouldEqual, 86400)
})
})
require.NoError(t, err)
assert.Equal(t, 86400, res.Period)
})
})
}

92
pkg/tsdb/cloudwatch/response_parser_test.go
Unescape View File

@ -7,12 +7,12 @@ import (
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/cloudwatch"
"github.com/grafana/grafana/pkg/components/null"
. "github.com/smartystreets/goconvey/convey"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestCloudWatchResponseParser(t *testing.T) {
Convey("TestCloudWatchResponseParser", t, func() {
Convey("can expand dimension value using exact match", func() {
t.Run("Expand dimension value using exact match", func(t *testing.T) {
timestamp := time.Unix(0, 0)
labels := []string{"lb1", "lb2"}
mdrs := map[string]*cloudwatch.MetricDataResult{
@ -62,19 +62,19 @@ func TestCloudWatchResponseParser(t *testing.T) {
Alias: "{{LoadBalancer}} Expanded",
}
series, partialData, err := parseGetMetricDataTimeSeries(mdrs, labels, query)
timeSeries := (*series)[0]
require.NoError(t, err)
So(err, ShouldBeNil)
So(partialData, ShouldBeFalse)
So(timeSeries.Name, ShouldEqual, "lb1 Expanded")
So(timeSeries.Tags["LoadBalancer"], ShouldEqual, "lb1")
timeSeries := (*series)[0]
assert.False(t, partialData)
assert.Equal(t, "lb1 Expanded", timeSeries.Name)
assert.Equal(t, "lb1", timeSeries.Tags["LoadBalancer"])
timeSeries2 := (*series)[1]
So(timeSeries2.Name, ShouldEqual, "lb2 Expanded")
So(timeSeries2.Tags["LoadBalancer"], ShouldEqual, "lb2")
assert.Equal(t, "lb2 Expanded", timeSeries2.Name)
assert.Equal(t, "lb2", timeSeries2.Tags["LoadBalancer"])
})
Convey("can expand dimension value using substring", func() {
t.Run("Expand dimension value using substring", func(t *testing.T) {
timestamp := time.Unix(0, 0)
labels := []string{"lb1 Sum", "lb2 Average"}
mdrs := map[string]*cloudwatch.MetricDataResult{
@ -124,18 +124,19 @@ func TestCloudWatchResponseParser(t *testing.T) {
Alias: "{{LoadBalancer}} Expanded",
}
series, partialData, err := parseGetMetricDataTimeSeries(mdrs, labels, query)
require.NoError(t, err)
timeSeries := (*series)[0]
So(err, ShouldBeNil)
So(partialData, ShouldBeFalse)
So(timeSeries.Name, ShouldEqual, "lb1 Expanded")
So(timeSeries.Tags["LoadBalancer"], ShouldEqual, "lb1")
assert.False(t, partialData)
assert.Equal(t, "lb1 Expanded", timeSeries.Name)
assert.Equal(t, "lb1", timeSeries.Tags["LoadBalancer"])
timeSeries2 := (*series)[1]
So(timeSeries2.Name, ShouldEqual, "lb2 Expanded")
So(timeSeries2.Tags["LoadBalancer"], ShouldEqual, "lb2")
assert.Equal(t, "lb2 Expanded", timeSeries2.Name)
assert.Equal(t, "lb2", timeSeries2.Tags["LoadBalancer"])
})
Convey("can expand dimension value using wildcard", func() {
t.Run("Expand dimension value using wildcard", func(t *testing.T) {
timestamp := time.Unix(0, 0)
labels := []string{"lb3", "lb4"}
mdrs := map[string]*cloudwatch.MetricDataResult{
@ -185,14 +186,13 @@ func TestCloudWatchResponseParser(t *testing.T) {
Alias: "{{LoadBalancer}} Expanded",
}
series, partialData, err := parseGetMetricDataTimeSeries(mdrs, labels, query)
So(err, ShouldBeNil)
So(partialData, ShouldBeFalse)
So((*series)[0].Name, ShouldEqual, "lb3 Expanded")
So((*series)[1].Name, ShouldEqual, "lb4 Expanded")
require.NoError(t, err)
assert.False(t, partialData)
assert.Equal(t, "lb3 Expanded", (*series)[0].Name)
assert.Equal(t, "lb4 Expanded", (*series)[1].Name)
})
Convey("can expand dimension value when no values are returned and a multi-valued template variable is used", func() {
t.Run("Expand dimension value when no values are returned and a multi-valued template variable is used", func(t *testing.T) {
timestamp := time.Unix(0, 0)
labels := []string{"lb3"}
mdrs := map[string]*cloudwatch.MetricDataResult{
@ -222,15 +222,14 @@ func TestCloudWatchResponseParser(t *testing.T) {
Alias: "{{LoadBalancer}} Expanded",
}
series, partialData, err := parseGetMetricDataTimeSeries(mdrs, labels, query)
So(err, ShouldBeNil)
So(partialData, ShouldBeFalse)
So(len(*series), ShouldEqual, 2)
So((*series)[0].Name, ShouldEqual, "lb1 Expanded")
So((*series)[1].Name, ShouldEqual, "lb2 Expanded")
require.NoError(t, err)
assert.False(t, partialData)
assert.Len(t, *series, 2)
assert.Equal(t, "lb1 Expanded", (*series)[0].Name)
assert.Equal(t, "lb2 Expanded", (*series)[1].Name)
})
Convey("can expand dimension value when no values are returned and a multi-valued template variable and two single-valued dimensions are used", func() {
t.Run("Expand dimension value when no values are returned and a multi-valued template variable and two single-valued dimensions are used", func(t *testing.T) {
timestamp := time.Unix(0, 0)
labels := []string{"lb3"}
mdrs := map[string]*cloudwatch.MetricDataResult{
@ -262,15 +261,14 @@ func TestCloudWatchResponseParser(t *testing.T) {
Alias: "{{LoadBalancer}} Expanded {{InstanceType}} - {{Resource}}",
}
series, partialData, err := parseGetMetricDataTimeSeries(mdrs, labels, query)
So(err, ShouldBeNil)
So(partialData, ShouldBeFalse)
So(len(*series), ShouldEqual, 2)
So((*series)[0].Name, ShouldEqual, "lb1 Expanded micro - res")
So((*series)[1].Name, ShouldEqual, "lb2 Expanded micro - res")
require.NoError(t, err)
assert.False(t, partialData)
assert.Len(t, *series, 2)
assert.Equal(t, "lb1 Expanded micro - res", (*series)[0].Name)
assert.Equal(t, "lb2 Expanded micro - res", (*series)[1].Name)
})
Convey("can parse cloudwatch response", func() {
t.Run("Parse cloudwatch response", func(t *testing.T) {
timestamp := time.Unix(0, 0)
labels := []string{"lb"}
mdrs := map[string]*cloudwatch.MetricDataResult{
@ -306,15 +304,13 @@ func TestCloudWatchResponseParser(t *testing.T) {
}
series, partialData, err := parseGetMetricDataTimeSeries(mdrs, labels, query)
timeSeries := (*series)[0]
So(err, ShouldBeNil)
So(partialData, ShouldBeFalse)
So(timeSeries.Name, ShouldEqual, "AWS/ApplicationELB_TargetResponseTime_Average")
So(timeSeries.Tags["LoadBalancer"], ShouldEqual, "lb")
So(timeSeries.Points[0][0].String(), ShouldEqual, null.FloatFrom(10.0).String())
So(timeSeries.Points[1][0].String(), ShouldEqual, null.FloatFrom(20.0).String())
So(timeSeries.Points[2][0].String(), ShouldEqual, null.FloatFromPtr(nil).String())
So(timeSeries.Points[3][0].String(), ShouldEqual, null.FloatFrom(30.0).String())
})
require.NoError(t, err)
assert.False(t, partialData)
assert.Equal(t, "AWS/ApplicationELB_TargetResponseTime_Average", timeSeries.Name)
assert.Equal(t, "lb", timeSeries.Tags["LoadBalancer"])
assert.Equal(t, null.FloatFrom(10.0).String(), timeSeries.Points[0][0].String())
assert.Equal(t, null.FloatFrom(20.0).String(), timeSeries.Points[1][0].String())
assert.Equal(t, null.FloatFromPtr(nil).String(), timeSeries.Points[2][0].String())
assert.Equal(t, null.FloatFrom(30.0).String(), timeSeries.Points[3][0].String())
})
}

Write Preview
Loading…
Cancel
Save