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. 293
      pkg/tsdb/cloudwatch/cloudwatch_query_test.go
  2. 354
      pkg/tsdb/cloudwatch/metric_data_query_builder_test.go
  3. 265
      pkg/tsdb/cloudwatch/query_transformer_test.go
  4. 394
      pkg/tsdb/cloudwatch/request_parser_test.go
  5. 558
      pkg/tsdb/cloudwatch/response_parser_test.go

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

@ -3,188 +3,137 @@ package cloudwatch
import ( import (
"testing" "testing"
. "github.com/smartystreets/goconvey/convey" "github.com/stretchr/testify/assert"
) )
func TestCloudWatchQuery(t *testing.T) { func TestCloudWatchQuery(t *testing.T) {
Convey("TestCloudWatchQuery", t, func() { t.Run("SEARCH(someexpression) was specified in the query editor", func(t *testing.T) {
Convey("and SEARCH(someexpression) was specified in the query editor", func() { query := &cloudWatchQuery{
query := &cloudWatchQuery{ RefId: "A",
RefId: "A", Region: "us-east-1",
Region: "us-east-1", Expression: "SEARCH(someexpression)",
Expression: "SEARCH(someexpression)", Stats: "Average",
Stats: "Average", Period: 300,
Period: 300, Id: "id1",
Id: "id1", }
}
assert.True(t, query.isSearchExpression(), "Expected a search expression")
Convey("it is a search expression", func() { assert.False(t, query.isMathExpression(), "Expected not math expression")
So(query.isSearchExpression(), ShouldBeTrue) })
})
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{ query := &cloudWatchQuery{
RefId: "A", RefId: "A",
Region: "us-east-1", Region: "us-east-1",
Expression: "", Expression: "",
Stats: "Average", Stats: "Average",
Period: 300, Period: 300,
Id: "id1", Id: "id1",
MatchExact: true, MatchExact: true,
Dimensions: map[string][]string{ Dimensions: map[string][]string{
"InstanceId": {"i-12345678"}, "InstanceId": {"i-12345678"},
}, },
} }
Convey("it is not a search expression", func() { assert.False(t, query.isSearchExpression(), "Expected not a search expression")
So(query.isSearchExpression(), ShouldBeFalse) assert.False(t, query.isMathExpression(), "Expected not math expressions")
}) })
Convey("it is not math expressions", func() {
So(query.isMathExpression(), ShouldBeFalse)
})
})
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{ query := &cloudWatchQuery{
RefId: "A", RefId: "A",
Region: "us-east-1", Region: "us-east-1",
Expression: "", Expression: "",
Stats: "Average", Stats: "Average",
Period: 300, Period: 300,
Id: "id1", Id: "id1",
Dimensions: map[string][]string{ Dimensions: map[string][]string{
"InstanceId": {"i-12345678", "i-34562312"}, "InstanceId": {"i-12345678", "i-34562312"},
}, },
} }
Convey("it is a search expression", func() { assert.True(t, query.isSearchExpression(), "Expected a search expression")
So(query.isSearchExpression(), ShouldBeTrue) assert.False(t, query.isMathExpression(), "Expected not math expressions")
}) })
Convey("it is not math expressions", func() {
So(query.isMathExpression(), ShouldBeFalse)
})
})
Convey("and no expression but dimension values has *", func() { t.Run("No expression but dimension values has *", func(t *testing.T) {
query := &cloudWatchQuery{ query := &cloudWatchQuery{
RefId: "A", RefId: "A",
Region: "us-east-1", Region: "us-east-1",
Expression: "", Expression: "",
Stats: "Average", Stats: "Average",
Period: 300, Period: 300,
Id: "id1", Id: "id1",
Dimensions: map[string][]string{ Dimensions: map[string][]string{
"InstanceId": {"i-12345678", "*"}, "InstanceId": {"i-12345678", "*"},
"InstanceType": {"abc", "def"}, "InstanceType": {"abc", "def"},
}, },
} }
Convey("it is not a search expression", func() { assert.True(t, query.isSearchExpression(), "Expected a search expression")
So(query.isSearchExpression(), ShouldBeTrue) assert.False(t, query.isMathExpression(), "Expected not math expression")
}) })
Convey("it is not math expressions", func() {
So(query.isMathExpression(), ShouldBeFalse)
})
})
Convey("and query has a multi-valued dimension", func() { t.Run("Query has a multi-valued dimension", func(t *testing.T) {
query := &cloudWatchQuery{ query := &cloudWatchQuery{
RefId: "A", RefId: "A",
Region: "us-east-1", Region: "us-east-1",
Expression: "", Expression: "",
Stats: "Average", Stats: "Average",
Period: 300, Period: 300,
Id: "id1", Id: "id1",
Dimensions: map[string][]string{ Dimensions: map[string][]string{
"InstanceId": {"i-12345678", "i-12345679"}, "InstanceId": {"i-12345678", "i-12345679"},
"InstanceType": {"abc"}, "InstanceType": {"abc"},
}, },
} }
Convey("it is a search expression", func() { assert.True(t, query.isSearchExpression(), "Expected a search expression")
So(query.isSearchExpression(), ShouldBeTrue) 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{ query := &cloudWatchQuery{
RefId: "A", RefId: "A",
Region: "us-east-1", Region: "us-east-1",
Expression: "", Expression: "",
Stats: "Average", Stats: "Average",
Period: 300, Period: 300,
Id: "id1", Id: "id1",
MatchExact: false, MatchExact: false,
Dimensions: make(map[string][]string), 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 query.MatchExact = false
Convey("it is a search expression", func() { assert.True(t, query.isSearchExpression(), "Expected a search expression")
So(query.isSearchExpression(), ShouldBeTrue) 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() {
query.MatchExact = true
Convey("it is a search expression", func() {
So(query.isSearchExpression(), ShouldBeFalse)
})
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 true", func(t *testing.T) {
query := &cloudWatchQuery{ query.MatchExact = true
RefId: "A", assert.False(t, query.isSearchExpression(), "Exxpected not search expression")
Region: "us-east-1", assert.False(t, query.isMathExpression(), "Expected not math expression")
Expression: "", assert.True(t, query.isMetricStat(), "Expected a metric stat")
Stats: "Average",
Period: 300,
Id: "id1",
MatchExact: false,
Dimensions: map[string][]string{
"InstanceId": {"i-12345678"},
},
}
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)
})
}) })
}) })
t.Run("Match exact is", func(t *testing.T) {
query := &cloudWatchQuery{
RefId: "A",
Region: "us-east-1",
Expression: "",
Stats: "Average",
Period: 300,
Id: "id1",
MatchExact: false,
Dimensions: map[string][]string{
"InstanceId": {"i-12345678"},
},
}
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")
})
} }

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

@ -3,199 +3,195 @@ package cloudwatch
import ( import (
"testing" "testing"
. "github.com/smartystreets/goconvey/convey" "github.com/stretchr/testify/assert"
) )
func TestMetricDataQueryBuilder(t *testing.T) { func TestMetricDataQueryBuilder_buildSearchExpression(t *testing.T) {
Convey("TestMetricDataQueryBuilder", t, func() { t.Run("Query should be matched exact", func(t *testing.T) {
Convey("buildSearchExpression", func() { const matchExact = true
Convey("and query should be matched exact", func() {
matchExact := true t.Run("Query has three dimension values for a given dimension key", func(t *testing.T) {
Convey("and query has three dimension values for a given dimension key", func() { query := &cloudWatchQuery{
query := &cloudWatchQuery{ Namespace: "AWS/EC2",
Namespace: "AWS/EC2", MetricName: "CPUUtilization",
MetricName: "CPUUtilization", Dimensions: map[string][]string{
Dimensions: map[string][]string{ "LoadBalancer": {"lb1", "lb2", "lb3"},
"LoadBalancer": {"lb1", "lb2", "lb3"}, },
}, Period: 300,
Period: 300, Expression: "",
Expression: "", MatchExact: matchExact,
MatchExact: matchExact, }
}
res := buildSearchExpression(query, "Average")
res := buildSearchExpression(query, "Average") assert.Equal(t, `REMOVE_EMPTY(SEARCH('{AWS/EC2,"LoadBalancer"} MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3")', 'Average', 300))`, res)
So(res, ShouldEqual, `REMOVE_EMPTY(SEARCH('{AWS/EC2,"LoadBalancer"} MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3")', 'Average', 300))`)
})
Convey("and query has three dimension values for two given dimension keys", func() {
query := &cloudWatchQuery{
Namespace: "AWS/EC2",
MetricName: "CPUUtilization",
Dimensions: map[string][]string{
"LoadBalancer": {"lb1", "lb2", "lb3"},
"InstanceId": {"i-123", "i-456", "i-789"},
},
Period: 300,
Expression: "",
MatchExact: matchExact,
}
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))`)
})
Convey("and no OR operator was added if a star was used for dimension value", func() {
query := &cloudWatchQuery{
Namespace: "AWS/EC2",
MetricName: "CPUUtilization",
Dimensions: map[string][]string{
"LoadBalancer": {"*"},
},
Period: 300,
Expression: "",
MatchExact: matchExact,
}
res := buildSearchExpression(query, "Average")
So(res, ShouldNotContainSubstring, "OR")
})
Convey("and query has one dimension key with a * value", func() {
query := &cloudWatchQuery{
Namespace: "AWS/EC2",
MetricName: "CPUUtilization",
Dimensions: map[string][]string{
"LoadBalancer": {"*"},
},
Period: 300,
Expression: "",
MatchExact: matchExact,
}
res := buildSearchExpression(query, "Average")
So(res, ShouldEqual, `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() {
query := &cloudWatchQuery{
Namespace: "AWS/EC2",
MetricName: "CPUUtilization",
Dimensions: map[string][]string{
"LoadBalancer": {"lb1", "lb2", "lb3"},
"InstanceId": {"i-123", "*", "i-789"},
},
Period: 300,
Expression: "",
MatchExact: matchExact,
}
res := buildSearchExpression(query, "Average")
So(res, ShouldEqual, `REMOVE_EMPTY(SEARCH('{AWS/EC2,"InstanceId","LoadBalancer"} MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3")', 'Average', 300))`)
})
Convey("and query has a dimension key with a space", func() {
query := &cloudWatchQuery{
Namespace: "AWS/Kafka",
MetricName: "CpuUser",
Dimensions: map[string][]string{
"Cluster Name": {"dev-cluster"},
},
Period: 300,
Expression: "",
MatchExact: matchExact,
}
res := buildSearchExpression(query, "Average")
So(res, ShouldEqual, `REMOVE_EMPTY(SEARCH('{AWS/Kafka,"Cluster Name"} MetricName="CpuUser" "Cluster Name"="dev-cluster"', 'Average', 300))`)
})
})
Convey("and query should not be matched exact", func() {
matchExact := false
Convey("and query has three dimension values for a given dimension key", func() {
query := &cloudWatchQuery{
Namespace: "AWS/EC2",
MetricName: "CPUUtilization",
Dimensions: map[string][]string{
"LoadBalancer": {"lb1", "lb2", "lb3"},
},
Period: 300,
Expression: "",
MatchExact: matchExact,
}
res := buildSearchExpression(query, "Average")
So(res, ShouldEqual, `REMOVE_EMPTY(SEARCH('Namespace="AWS/EC2" MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3")', 'Average', 300))`)
})
Convey("and query has three dimension values for two given dimension keys", func() {
query := &cloudWatchQuery{
Namespace: "AWS/EC2",
MetricName: "CPUUtilization",
Dimensions: map[string][]string{
"LoadBalancer": {"lb1", "lb2", "lb3"},
"InstanceId": {"i-123", "i-456", "i-789"},
},
Period: 300,
Expression: "",
MatchExact: matchExact,
}
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))`)
})
Convey("and query has one dimension key with a * value", func() {
query := &cloudWatchQuery{
Namespace: "AWS/EC2",
MetricName: "CPUUtilization",
Dimensions: map[string][]string{
"LoadBalancer": {"*"},
},
Period: 300,
Expression: "",
MatchExact: matchExact,
}
res := buildSearchExpression(query, "Average")
So(res, ShouldEqual, `REMOVE_EMPTY(SEARCH('Namespace="AWS/EC2" MetricName="CPUUtilization" "LoadBalancer"', 'Average', 300))`)
})
Convey("and query has three dimension values for two given dimension keys, and one value is a star", func() {
query := &cloudWatchQuery{
Namespace: "AWS/EC2",
MetricName: "CPUUtilization",
Dimensions: map[string][]string{
"LoadBalancer": {"lb1", "lb2", "lb3"},
"InstanceId": {"i-123", "*", "i-789"},
},
Period: 300,
Expression: "",
MatchExact: matchExact,
}
res := buildSearchExpression(query, "Average")
So(res, ShouldEqual, `REMOVE_EMPTY(SEARCH('Namespace="AWS/EC2" MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3") "InstanceId"', 'Average', 300))`)
})
})
}) })
Convey("and query has invalid characters in dimension values", func() { t.Run("Query has three dimension values for two given dimension keys", func(t *testing.T) {
query := &cloudWatchQuery{ query := &cloudWatchQuery{
Namespace: "AWS/EC2", Namespace: "AWS/EC2",
MetricName: "CPUUtilization", MetricName: "CPUUtilization",
Dimensions: map[string][]string{ Dimensions: map[string][]string{
"lb4": {`lb4""`}, "LoadBalancer": {"lb1", "lb2", "lb3"},
"InstanceId": {"i-123", "i-456", "i-789"},
}, },
Period: 300, Period: 300,
Expression: "", Expression: "",
MatchExact: true, MatchExact: matchExact,
} }
res := buildSearchExpression(query, "Average") res := buildSearchExpression(query, "Average")
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)
})
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",
Dimensions: map[string][]string{
"LoadBalancer": {"*"},
},
Period: 300,
Expression: "",
MatchExact: matchExact,
}
Convey("it should escape double quotes", func() { res := buildSearchExpression(query, "Average")
So(res, ShouldContainSubstring, `lb4\"\"`) assert.NotContains(t, res, "OR")
})
}) })
t.Run("Query has one dimension key with a * value", func(t *testing.T) {
query := &cloudWatchQuery{
Namespace: "AWS/EC2",
MetricName: "CPUUtilization",
Dimensions: map[string][]string{
"LoadBalancer": {"*"},
},
Period: 300,
Expression: "",
MatchExact: matchExact,
}
res := buildSearchExpression(query, "Average")
assert.Equal(t, res, `REMOVE_EMPTY(SEARCH('{AWS/EC2,"LoadBalancer"} MetricName="CPUUtilization"', 'Average', 300))`)
})
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",
Dimensions: map[string][]string{
"LoadBalancer": {"lb1", "lb2", "lb3"},
"InstanceId": {"i-123", "*", "i-789"},
},
Period: 300,
Expression: "",
MatchExact: matchExact,
}
res := buildSearchExpression(query, "Average")
assert.Equal(t, `REMOVE_EMPTY(SEARCH('{AWS/EC2,"InstanceId","LoadBalancer"} MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3")', 'Average', 300))`, res)
})
t.Run("Query has a dimension key with a space", func(t *testing.T) {
query := &cloudWatchQuery{
Namespace: "AWS/Kafka",
MetricName: "CpuUser",
Dimensions: map[string][]string{
"Cluster Name": {"dev-cluster"},
},
Period: 300,
Expression: "",
MatchExact: matchExact,
}
res := buildSearchExpression(query, "Average")
assert.Equal(t, `REMOVE_EMPTY(SEARCH('{AWS/Kafka,"Cluster Name"} MetricName="CpuUser" "Cluster Name"="dev-cluster"', 'Average', 300))`, res)
})
})
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",
Dimensions: map[string][]string{
"LoadBalancer": {"lb1", "lb2", "lb3"},
},
Period: 300,
Expression: "",
MatchExact: matchExact,
}
res := buildSearchExpression(query, "Average")
assert.Equal(t, `REMOVE_EMPTY(SEARCH('Namespace="AWS/EC2" MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3")', 'Average', 300))`, res)
})
t.Run("Query has three dimension values for two given dimension keys", func(t *testing.T) {
query := &cloudWatchQuery{
Namespace: "AWS/EC2",
MetricName: "CPUUtilization",
Dimensions: map[string][]string{
"LoadBalancer": {"lb1", "lb2", "lb3"},
"InstanceId": {"i-123", "i-456", "i-789"},
},
Period: 300,
Expression: "",
MatchExact: matchExact,
}
res := buildSearchExpression(query, "Average")
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)
})
t.Run("Query has one dimension key with a * value", func(t *testing.T) {
query := &cloudWatchQuery{
Namespace: "AWS/EC2",
MetricName: "CPUUtilization",
Dimensions: map[string][]string{
"LoadBalancer": {"*"},
},
Period: 300,
Expression: "",
MatchExact: matchExact,
}
res := buildSearchExpression(query, "Average")
assert.Equal(t, `REMOVE_EMPTY(SEARCH('Namespace="AWS/EC2" MetricName="CPUUtilization" "LoadBalancer"', 'Average', 300))`, res)
})
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",
Dimensions: map[string][]string{
"LoadBalancer": {"lb1", "lb2", "lb3"},
"InstanceId": {"i-123", "*", "i-789"},
},
Period: 300,
Expression: "",
MatchExact: matchExact,
}
res := buildSearchExpression(query, "Average")
assert.Equal(t, `REMOVE_EMPTY(SEARCH('Namespace="AWS/EC2" MetricName="CPUUtilization" "LoadBalancer"=("lb1" OR "lb2" OR "lb3") "InstanceId"', 'Average', 300))`, res)
})
})
t.Run("Query has invalid characters in dimension values", func(t *testing.T) {
query := &cloudWatchQuery{
Namespace: "AWS/EC2",
MetricName: "CPUUtilization",
Dimensions: map[string][]string{
"lb4": {`lb4""`},
},
Period: 300,
Expression: "",
MatchExact: true,
}
res := buildSearchExpression(query, "Average")
assert.Contains(t, res, `lb4\"\"`, "Expected escape double quotes")
}) })
} }

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

@ -4,155 +4,150 @@ import (
"testing" "testing"
"github.com/aws/aws-sdk-go/aws" "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) { func TestQueryTransformer(t *testing.T) {
Convey("TestQueryTransformer", t, func() { executor := newExecutor()
Convey("when transforming queries", func() { t.Run("One cloudwatchQuery is generated when its request query has one stat", func(t *testing.T) {
executor := newExecutor() requestQueries := []*requestQuery{
Convey("one cloudwatchQuery is generated when its request query has one stat", func() { {
requestQueries := []*requestQuery{ RefId: "D",
{ Region: "us-east-1",
RefId: "D", Namespace: "ec2",
Region: "us-east-1", MetricName: "CPUUtilization",
Namespace: "ec2", Statistics: aws.StringSlice([]string{"Average"}),
MetricName: "CPUUtilization", Period: 600,
Statistics: aws.StringSlice([]string{"Average"}), Id: "",
Period: 600, },
Id: "", }
},
}
res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries) res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
So(err, ShouldBeNil) require.NoError(t, err)
So(len(res), ShouldEqual, 1) 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{ requestQueries := []*requestQuery{
{ {
RefId: "D", RefId: "D",
Region: "us-east-1", Region: "us-east-1",
Namespace: "ec2", Namespace: "ec2",
MetricName: "CPUUtilization", MetricName: "CPUUtilization",
Statistics: aws.StringSlice([]string{"Average", "Sum"}), Statistics: aws.StringSlice([]string{"Average", "Sum"}),
Period: 600, Period: 600,
Id: "", Id: "",
}, },
} }
res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries) res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
So(err, ShouldBeNil) require.NoError(t, err)
So(len(res), ShouldEqual, 2) assert.Len(t, res, 2)
}) })
Convey("and id is given by user", func() { t.Run("id is given by user that will be used in the cloudwatch query", func(t *testing.T) {
Convey("that id will be used in the cloudwatch query", func() { requestQueries := []*requestQuery{
requestQueries := []*requestQuery{ {
{ RefId: "D",
RefId: "D", Region: "us-east-1",
Region: "us-east-1", Namespace: "ec2",
Namespace: "ec2", MetricName: "CPUUtilization",
MetricName: "CPUUtilization", Statistics: aws.StringSlice([]string{"Average"}),
Statistics: aws.StringSlice([]string{"Average"}), Period: 600,
Period: 600, Id: "myid",
Id: "myid", },
}, }
}
res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries) res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
So(err, ShouldBeNil) require.Nil(t, err)
So(len(res), ShouldEqual, 1) assert.Equal(t, len(res), 1)
So(res, ShouldContainKey, "myid") assert.Contains(t, res, "myid")
}) })
})
Convey("and id is not given by user", func() { t.Run("ID is not given by user", func(t *testing.T) {
Convey("id will be generated based on ref id if query only has one stat", func() { t.Run("ID will be generated based on ref ID if query only has one stat", func(t *testing.T) {
requestQueries := []*requestQuery{ requestQueries := []*requestQuery{
{ {
RefId: "D", RefId: "D",
Region: "us-east-1", Region: "us-east-1",
Namespace: "ec2", Namespace: "ec2",
MetricName: "CPUUtilization", MetricName: "CPUUtilization",
Statistics: aws.StringSlice([]string{"Average"}), Statistics: aws.StringSlice([]string{"Average"}),
Period: 600, Period: 600,
Id: "", Id: "",
}, },
} }
res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries) res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
So(err, ShouldBeNil) require.NoError(t, err)
So(len(res), ShouldEqual, 1) assert.Len(t, res, 1)
So(res, ShouldContainKey, "queryD") 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{ requestQueries := []*requestQuery{
{ {
RefId: "D", RefId: "D",
Region: "us-east-1", Region: "us-east-1",
Namespace: "ec2", Namespace: "ec2",
MetricName: "CPUUtilization", MetricName: "CPUUtilization",
Statistics: aws.StringSlice([]string{"Average", "Sum"}), Statistics: aws.StringSlice([]string{"Average", "Sum"}),
Period: 600, Period: 600,
Id: "", Id: "",
}, },
} }
res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries) res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
So(err, ShouldBeNil) require.NoError(t, err)
So(len(res), ShouldEqual, 2) assert.Len(t, res, 2)
So(res, ShouldContainKey, "queryD_Sum") assert.Contains(t, res, "queryD_Sum")
So(res, ShouldContainKey, "queryD_Average") 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{ requestQueries := []*requestQuery{
{ {
RefId: "D", RefId: "D",
Region: "us-east-1", Region: "us-east-1",
Namespace: "ec2", Namespace: "ec2",
MetricName: "CPUUtilization", MetricName: "CPUUtilization",
Statistics: aws.StringSlice([]string{"Average", "p46.32"}), Statistics: aws.StringSlice([]string{"Average", "p46.32"}),
Period: 600, Period: 600,
Id: "", Id: "",
}, },
} }
res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries) res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
So(err, ShouldBeNil) require.NoError(t, err)
So(len(res), ShouldEqual, 2) assert.Len(t, res, 2)
So(res, ShouldContainKey, "queryD_p46_32") 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{ requestQueries := []*requestQuery{
{ {
RefId: "D", RefId: "D",
Region: "us-east-1", Region: "us-east-1",
Namespace: "ec2", Namespace: "ec2",
MetricName: "CPUUtilization", MetricName: "CPUUtilization",
Statistics: aws.StringSlice([]string{"Average", "p46.32"}), Statistics: aws.StringSlice([]string{"Average", "p46.32"}),
Period: 600, Period: 600,
Id: "myId", Id: "myId",
}, },
{ {
RefId: "E", RefId: "E",
Region: "us-east-1", Region: "us-east-1",
Namespace: "ec2", Namespace: "ec2",
MetricName: "CPUUtilization", MetricName: "CPUUtilization",
Statistics: aws.StringSlice([]string{"Average", "p46.32"}), Statistics: aws.StringSlice([]string{"Average", "p46.32"}),
Period: 600, Period: 600,
Id: "myId", Id: "myId",
}, },
} }
res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries) res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
So(res, ShouldBeNil) require.Nil(t, res)
So(err, ShouldNotBeNil) assert.Error(t, err)
})
})
}) })
} }

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

@ -6,211 +6,207 @@ import (
"github.com/grafana/grafana/pkg/components/simplejson" "github.com/grafana/grafana/pkg/components/simplejson"
"github.com/grafana/grafana/pkg/tsdb" "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) { func TestRequestParser(t *testing.T) {
Convey("TestRequestParser", t, func() { timeRange := tsdb.NewTimeRange("now-1h", "now-2h")
from, err := timeRange.ParseFrom()
require.NoError(t, err)
to, err := timeRange.ParseTo()
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",
"namespace": "ec2",
"metricName": "CPUUtilization",
"id": "",
"expression": "",
"dimensions": map[string]interface{}{
"InstanceId": []interface{}{"test"},
"InstanceType": []interface{}{"test2", "test3"},
},
"statistics": []interface{}{"Average"},
"period": "600",
"hide": false,
})
res, err := parseRequestQuery(query, "ref1", from, to)
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",
"namespace": "ec2",
"metricName": "CPUUtilization",
"id": "",
"expression": "",
"dimensions": map[string]interface{}{
"InstanceId": "test",
"InstanceType": "test2",
},
"statistics": []interface{}{"Average"},
"period": "600",
"hide": false,
})
res, err := parseRequestQuery(query, "ref1", from, to)
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",
"namespace": "ec2",
"metricName": "CPUUtilization",
"id": "",
"expression": "",
"dimensions": map[string]interface{}{
"InstanceId": "test",
"InstanceType": "test2",
},
"statistics": []interface{}{"Average"},
"hide": false,
})
query.Set("period", "900")
timeRange := tsdb.NewTimeRange("now-1h", "now-2h") timeRange := tsdb.NewTimeRange("now-1h", "now-2h")
from, err := timeRange.ParseFrom() from, err := timeRange.ParseFrom()
So(err, ShouldBeNil) require.NoError(t, err)
to, err := timeRange.ParseTo() to, err := timeRange.ParseTo()
So(err, ShouldBeNil) require.NoError(t, err)
Convey("when parsing query editor row json", func() {
Convey("using new dimensions structure", func() { res, err := parseRequestQuery(query, "ref1", from, to)
query := simplejson.NewFromAny(map[string]interface{}{ require.NoError(t, err)
"refId": "ref1", assert.Equal(t, 900, res.Period)
"region": "us-east-1", })
"namespace": "ec2",
"metricName": "CPUUtilization", t.Run("Period is parsed correctly if not defined by user", func(t *testing.T) {
"id": "", query := simplejson.NewFromAny(map[string]interface{}{
"expression": "", "refId": "ref1",
"dimensions": map[string]interface{}{ "region": "us-east-1",
"InstanceId": []interface{}{"test"}, "namespace": "ec2",
"InstanceType": []interface{}{"test2", "test3"}, "metricName": "CPUUtilization",
}, "id": "",
"statistics": []interface{}{"Average"}, "expression": "",
"period": "600", "dimensions": map[string]interface{}{
"hide": false, "InstanceId": "test",
}) "InstanceType": "test2",
},
res, err := parseRequestQuery(query, "ref1", from, to) "statistics": []interface{}{"Average"},
So(err, ShouldBeNil) "hide": false,
So(res.Region, ShouldEqual, "us-east-1") "period": "auto",
So(res.RefId, ShouldEqual, "ref1") })
So(res.Namespace, ShouldEqual, "ec2")
So(res.MetricName, ShouldEqual, "CPUUtilization") t.Run("Time range is 5 minutes", func(t *testing.T) {
So(res.Id, ShouldEqual, "") query.Set("period", "auto")
So(res.Expression, ShouldEqual, "") to := time.Now()
So(res.Period, ShouldEqual, 600) from := to.Local().Add(time.Minute * time.Duration(5))
So(res.ReturnData, ShouldEqual, true)
So(len(res.Dimensions), ShouldEqual, 2) res, err := parseRequestQuery(query, "ref1", from, to)
So(len(res.Dimensions["InstanceId"]), ShouldEqual, 1) require.NoError(t, err)
So(len(res.Dimensions["InstanceType"]), ShouldEqual, 2) assert.Equal(t, 60, res.Period)
So(res.Dimensions["InstanceType"][1], ShouldEqual, "test3") })
So(len(res.Statistics), ShouldEqual, 1)
So(*res.Statistics[0], ShouldEqual, "Average") t.Run("Time range is 1 day", func(t *testing.T) {
}) query.Set("period", "auto")
to := time.Now()
Convey("using old dimensions structure (backwards compatibility)", func() { from := to.AddDate(0, 0, -1)
query := simplejson.NewFromAny(map[string]interface{}{
"refId": "ref1", res, err := parseRequestQuery(query, "ref1", from, to)
"region": "us-east-1", require.NoError(t, err)
"namespace": "ec2", assert.Equal(t, 60, res.Period)
"metricName": "CPUUtilization", })
"id": "",
"expression": "", t.Run("Time range is 2 days", func(t *testing.T) {
"dimensions": map[string]interface{}{ query.Set("period", "auto")
"InstanceId": "test", to := time.Now()
"InstanceType": "test2", from := to.AddDate(0, 0, -2)
}, res, err := parseRequestQuery(query, "ref1", from, to)
"statistics": []interface{}{"Average"}, require.NoError(t, err)
"period": "600", assert.Equal(t, 300, res.Period)
"hide": false, })
})
t.Run("Time range is 7 days", func(t *testing.T) {
res, err := parseRequestQuery(query, "ref1", from, to) query.Set("period", "auto")
So(err, ShouldBeNil) to := time.Now()
So(res.Region, ShouldEqual, "us-east-1") from := to.AddDate(0, 0, -7)
So(res.RefId, ShouldEqual, "ref1")
So(res.Namespace, ShouldEqual, "ec2") res, err := parseRequestQuery(query, "ref1", from, to)
So(res.MetricName, ShouldEqual, "CPUUtilization") require.NoError(t, err)
So(res.Id, ShouldEqual, "") assert.Equal(t, 900, res.Period)
So(res.Expression, ShouldEqual, "") })
So(res.Period, ShouldEqual, 600)
So(res.ReturnData, ShouldEqual, true) t.Run("Time range is 30 days", func(t *testing.T) {
So(len(res.Dimensions), ShouldEqual, 2) query.Set("period", "auto")
So(len(res.Dimensions["InstanceId"]), ShouldEqual, 1) to := time.Now()
So(len(res.Dimensions["InstanceType"]), ShouldEqual, 1) from := to.AddDate(0, 0, -30)
So(res.Dimensions["InstanceType"][0], ShouldEqual, "test2")
So(*res.Statistics[0], ShouldEqual, "Average") res, err := parseRequestQuery(query, "ref1", from, to)
}) require.NoError(t, err)
assert.Equal(t, 3600, res.Period)
Convey("period defined in the editor by the user is being used", func() { })
query := simplejson.NewFromAny(map[string]interface{}{
"refId": "ref1", t.Run("Time range is 90 days", func(t *testing.T) {
"region": "us-east-1", query.Set("period", "auto")
"namespace": "ec2", to := time.Now()
"metricName": "CPUUtilization", from := to.AddDate(0, 0, -90)
"id": "",
"expression": "", res, err := parseRequestQuery(query, "ref1", from, to)
"dimensions": map[string]interface{}{ require.NoError(t, err)
"InstanceId": "test", assert.Equal(t, 21600, res.Period)
"InstanceType": "test2", })
},
"statistics": []interface{}{"Average"}, t.Run("Time range is 1 year", func(t *testing.T) {
"hide": false, query.Set("period", "auto")
}) to := time.Now()
Convey("when time range is short", func() { from := to.AddDate(-1, 0, 0)
query.Set("period", "900")
timeRange := tsdb.NewTimeRange("now-1h", "now-2h") res, err := parseRequestQuery(query, "ref1", from, to)
from, err := timeRange.ParseFrom() require.Nil(t, err)
So(err, ShouldBeNil) assert.Equal(t, res.Period, 21600)
to, err := timeRange.ParseTo() })
So(err, ShouldBeNil)
t.Run("Time range is 2 years", func(t *testing.T) {
res, err := parseRequestQuery(query, "ref1", from, to) query.Set("period", "auto")
So(err, ShouldBeNil) to := time.Now()
So(res.Period, ShouldEqual, 900) from := to.AddDate(-2, 0, 0)
})
}) res, err := parseRequestQuery(query, "ref1", from, to)
require.NoError(t, err)
Convey("period is parsed correctly if not defined by user", func() { assert.Equal(t, 86400, res.Period)
query := simplejson.NewFromAny(map[string]interface{}{
"refId": "ref1",
"region": "us-east-1",
"namespace": "ec2",
"metricName": "CPUUtilization",
"id": "",
"expression": "",
"dimensions": map[string]interface{}{
"InstanceId": "test",
"InstanceType": "test2",
},
"statistics": []interface{}{"Average"},
"hide": false,
"period": "auto",
})
Convey("when time range is 5 minutes", func() {
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)
})
Convey("when time range is 1 day", func() {
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)
})
Convey("when time range is 2 days", func() {
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)
})
Convey("when time range is 7 days", func() {
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)
})
Convey("when time range is 30 days", func() {
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)
})
Convey("when time range is 90 days", func() {
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)
})
Convey("when time range is 1 year", func() {
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)
})
Convey("when time range is 2 years", func() {
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)
})
})
}) })
}) })
} }

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

@ -7,314 +7,310 @@ import (
"github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/service/cloudwatch" "github.com/aws/aws-sdk-go/service/cloudwatch"
"github.com/grafana/grafana/pkg/components/null" "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) { func TestCloudWatchResponseParser(t *testing.T) {
Convey("TestCloudWatchResponseParser", t, func() { t.Run("Expand dimension value using exact match", func(t *testing.T) {
Convey("can expand dimension value using exact match", func() { timestamp := time.Unix(0, 0)
timestamp := time.Unix(0, 0) labels := []string{"lb1", "lb2"}
labels := []string{"lb1", "lb2"} mdrs := map[string]*cloudwatch.MetricDataResult{
mdrs := map[string]*cloudwatch.MetricDataResult{ "lb1": {
"lb1": { Id: aws.String("id1"),
Id: aws.String("id1"), Label: aws.String("lb1"),
Label: aws.String("lb1"), Timestamps: []*time.Time{
Timestamps: []*time.Time{ aws.Time(timestamp),
aws.Time(timestamp), aws.Time(timestamp.Add(60 * time.Second)),
aws.Time(timestamp.Add(60 * time.Second)), aws.Time(timestamp.Add(180 * time.Second)),
aws.Time(timestamp.Add(180 * time.Second)),
},
Values: []*float64{
aws.Float64(10),
aws.Float64(20),
aws.Float64(30),
},
StatusCode: aws.String("Complete"),
}, },
"lb2": { Values: []*float64{
Id: aws.String("id2"), aws.Float64(10),
Label: aws.String("lb2"), aws.Float64(20),
Timestamps: []*time.Time{ aws.Float64(30),
aws.Time(timestamp),
aws.Time(timestamp.Add(60 * time.Second)),
aws.Time(timestamp.Add(180 * time.Second)),
},
Values: []*float64{
aws.Float64(10),
aws.Float64(20),
aws.Float64(30),
},
StatusCode: aws.String("Complete"),
}, },
} StatusCode: aws.String("Complete"),
},
query := &cloudWatchQuery{ "lb2": {
RefId: "refId1", Id: aws.String("id2"),
Region: "us-east-1", Label: aws.String("lb2"),
Namespace: "AWS/ApplicationELB", Timestamps: []*time.Time{
MetricName: "TargetResponseTime", aws.Time(timestamp),
Dimensions: map[string][]string{ aws.Time(timestamp.Add(60 * time.Second)),
"LoadBalancer": {"lb1", "lb2"}, aws.Time(timestamp.Add(180 * time.Second)),
"TargetGroup": {"tg"}, },
Values: []*float64{
aws.Float64(10),
aws.Float64(20),
aws.Float64(30),
}, },
Stats: "Average", StatusCode: aws.String("Complete"),
Period: 60, },
Alias: "{{LoadBalancer}} Expanded", }
}
series, partialData, err := parseGetMetricDataTimeSeries(mdrs, labels, query)
timeSeries := (*series)[0]
So(err, ShouldBeNil) query := &cloudWatchQuery{
So(partialData, ShouldBeFalse) RefId: "refId1",
So(timeSeries.Name, ShouldEqual, "lb1 Expanded") Region: "us-east-1",
So(timeSeries.Tags["LoadBalancer"], ShouldEqual, "lb1") Namespace: "AWS/ApplicationELB",
MetricName: "TargetResponseTime",
Dimensions: map[string][]string{
"LoadBalancer": {"lb1", "lb2"},
"TargetGroup": {"tg"},
},
Stats: "Average",
Period: 60,
Alias: "{{LoadBalancer}} Expanded",
}
series, partialData, err := parseGetMetricDataTimeSeries(mdrs, labels, query)
require.NoError(t, err)
timeSeries2 := (*series)[1] timeSeries := (*series)[0]
So(timeSeries2.Name, ShouldEqual, "lb2 Expanded") assert.False(t, partialData)
So(timeSeries2.Tags["LoadBalancer"], ShouldEqual, "lb2") assert.Equal(t, "lb1 Expanded", timeSeries.Name)
}) assert.Equal(t, "lb1", timeSeries.Tags["LoadBalancer"])
Convey("can expand dimension value using substring", func() { timeSeries2 := (*series)[1]
timestamp := time.Unix(0, 0) assert.Equal(t, "lb2 Expanded", timeSeries2.Name)
labels := []string{"lb1 Sum", "lb2 Average"} assert.Equal(t, "lb2", timeSeries2.Tags["LoadBalancer"])
mdrs := map[string]*cloudwatch.MetricDataResult{ })
"lb1 Sum": {
Id: aws.String("id1"),
Label: aws.String("lb1 Sum"),
Timestamps: []*time.Time{
aws.Time(timestamp),
aws.Time(timestamp.Add(60 * time.Second)),
aws.Time(timestamp.Add(180 * time.Second)),
},
Values: []*float64{
aws.Float64(10),
aws.Float64(20),
aws.Float64(30),
},
StatusCode: aws.String("Complete"),
},
"lb2 Average": {
Id: aws.String("id2"),
Label: aws.String("lb2 Average"),
Timestamps: []*time.Time{
aws.Time(timestamp),
aws.Time(timestamp.Add(60 * time.Second)),
aws.Time(timestamp.Add(180 * time.Second)),
},
Values: []*float64{
aws.Float64(10),
aws.Float64(20),
aws.Float64(30),
},
StatusCode: aws.String("Complete"),
},
}
query := &cloudWatchQuery{ t.Run("Expand dimension value using substring", func(t *testing.T) {
RefId: "refId1", timestamp := time.Unix(0, 0)
Region: "us-east-1", labels := []string{"lb1 Sum", "lb2 Average"}
Namespace: "AWS/ApplicationELB", mdrs := map[string]*cloudwatch.MetricDataResult{
MetricName: "TargetResponseTime", "lb1 Sum": {
Dimensions: map[string][]string{ Id: aws.String("id1"),
"LoadBalancer": {"lb1", "lb2"}, Label: aws.String("lb1 Sum"),
"TargetGroup": {"tg"}, Timestamps: []*time.Time{
aws.Time(timestamp),
aws.Time(timestamp.Add(60 * time.Second)),
aws.Time(timestamp.Add(180 * time.Second)),
}, },
Stats: "Average", Values: []*float64{
Period: 60, aws.Float64(10),
Alias: "{{LoadBalancer}} Expanded", aws.Float64(20),
} aws.Float64(30),
series, partialData, err := parseGetMetricDataTimeSeries(mdrs, labels, query)
timeSeries := (*series)[0]
So(err, ShouldBeNil)
So(partialData, ShouldBeFalse)
So(timeSeries.Name, ShouldEqual, "lb1 Expanded")
So(timeSeries.Tags["LoadBalancer"], ShouldEqual, "lb1")
timeSeries2 := (*series)[1]
So(timeSeries2.Name, ShouldEqual, "lb2 Expanded")
So(timeSeries2.Tags["LoadBalancer"], ShouldEqual, "lb2")
})
Convey("can expand dimension value using wildcard", func() {
timestamp := time.Unix(0, 0)
labels := []string{"lb3", "lb4"}
mdrs := map[string]*cloudwatch.MetricDataResult{
"lb3": {
Id: aws.String("lb3"),
Label: aws.String("lb3"),
Timestamps: []*time.Time{
aws.Time(timestamp),
aws.Time(timestamp.Add(60 * time.Second)),
aws.Time(timestamp.Add(180 * time.Second)),
},
Values: []*float64{
aws.Float64(10),
aws.Float64(20),
aws.Float64(30),
},
StatusCode: aws.String("Complete"),
}, },
"lb4": { StatusCode: aws.String("Complete"),
Id: aws.String("lb4"), },
Label: aws.String("lb4"), "lb2 Average": {
Timestamps: []*time.Time{ Id: aws.String("id2"),
aws.Time(timestamp), Label: aws.String("lb2 Average"),
aws.Time(timestamp.Add(60 * time.Second)), Timestamps: []*time.Time{
aws.Time(timestamp.Add(180 * time.Second)), aws.Time(timestamp),
}, aws.Time(timestamp.Add(60 * time.Second)),
Values: []*float64{ aws.Time(timestamp.Add(180 * time.Second)),
aws.Float64(10),
aws.Float64(20),
aws.Float64(30),
},
StatusCode: aws.String("Complete"),
}, },
} Values: []*float64{
aws.Float64(10),
query := &cloudWatchQuery{ aws.Float64(20),
RefId: "refId1", aws.Float64(30),
Region: "us-east-1",
Namespace: "AWS/ApplicationELB",
MetricName: "TargetResponseTime",
Dimensions: map[string][]string{
"LoadBalancer": {"*"},
"TargetGroup": {"tg"},
}, },
Stats: "Average", StatusCode: aws.String("Complete"),
Period: 60, },
Alias: "{{LoadBalancer}} Expanded", }
}
series, partialData, err := parseGetMetricDataTimeSeries(mdrs, labels, query)
So(err, ShouldBeNil) query := &cloudWatchQuery{
So(partialData, ShouldBeFalse) RefId: "refId1",
So((*series)[0].Name, ShouldEqual, "lb3 Expanded") Region: "us-east-1",
So((*series)[1].Name, ShouldEqual, "lb4 Expanded") Namespace: "AWS/ApplicationELB",
}) MetricName: "TargetResponseTime",
Dimensions: map[string][]string{
"LoadBalancer": {"lb1", "lb2"},
"TargetGroup": {"tg"},
},
Stats: "Average",
Period: 60,
Alias: "{{LoadBalancer}} Expanded",
}
series, partialData, err := parseGetMetricDataTimeSeries(mdrs, labels, query)
require.NoError(t, err)
Convey("can expand dimension value when no values are returned and a multi-valued template variable is used", func() { timeSeries := (*series)[0]
timestamp := time.Unix(0, 0) assert.False(t, partialData)
labels := []string{"lb3"} assert.Equal(t, "lb1 Expanded", timeSeries.Name)
mdrs := map[string]*cloudwatch.MetricDataResult{ assert.Equal(t, "lb1", timeSeries.Tags["LoadBalancer"])
"lb3": {
Id: aws.String("lb3"),
Label: aws.String("lb3"),
Timestamps: []*time.Time{
aws.Time(timestamp),
aws.Time(timestamp.Add(60 * time.Second)),
aws.Time(timestamp.Add(180 * time.Second)),
},
Values: []*float64{},
StatusCode: aws.String("Complete"),
},
}
query := &cloudWatchQuery{ timeSeries2 := (*series)[1]
RefId: "refId1", assert.Equal(t, "lb2 Expanded", timeSeries2.Name)
Region: "us-east-1", assert.Equal(t, "lb2", timeSeries2.Tags["LoadBalancer"])
Namespace: "AWS/ApplicationELB", })
MetricName: "TargetResponseTime",
Dimensions: map[string][]string{ t.Run("Expand dimension value using wildcard", func(t *testing.T) {
"LoadBalancer": {"lb1", "lb2"}, timestamp := time.Unix(0, 0)
labels := []string{"lb3", "lb4"}
mdrs := map[string]*cloudwatch.MetricDataResult{
"lb3": {
Id: aws.String("lb3"),
Label: aws.String("lb3"),
Timestamps: []*time.Time{
aws.Time(timestamp),
aws.Time(timestamp.Add(60 * time.Second)),
aws.Time(timestamp.Add(180 * time.Second)),
},
Values: []*float64{
aws.Float64(10),
aws.Float64(20),
aws.Float64(30),
},
StatusCode: aws.String("Complete"),
},
"lb4": {
Id: aws.String("lb4"),
Label: aws.String("lb4"),
Timestamps: []*time.Time{
aws.Time(timestamp),
aws.Time(timestamp.Add(60 * time.Second)),
aws.Time(timestamp.Add(180 * time.Second)),
}, },
Stats: "Average", Values: []*float64{
Period: 60, aws.Float64(10),
Alias: "{{LoadBalancer}} Expanded", aws.Float64(20),
} aws.Float64(30),
series, partialData, err := parseGetMetricDataTimeSeries(mdrs, labels, query) },
StatusCode: aws.String("Complete"),
},
}
So(err, ShouldBeNil) query := &cloudWatchQuery{
So(partialData, ShouldBeFalse) RefId: "refId1",
So(len(*series), ShouldEqual, 2) Region: "us-east-1",
So((*series)[0].Name, ShouldEqual, "lb1 Expanded") Namespace: "AWS/ApplicationELB",
So((*series)[1].Name, ShouldEqual, "lb2 Expanded") MetricName: "TargetResponseTime",
}) Dimensions: map[string][]string{
"LoadBalancer": {"*"},
"TargetGroup": {"tg"},
},
Stats: "Average",
Period: 60,
Alias: "{{LoadBalancer}} Expanded",
}
series, partialData, err := parseGetMetricDataTimeSeries(mdrs, labels, query)
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 and two single-valued dimensions are 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) timestamp := time.Unix(0, 0)
labels := []string{"lb3"} labels := []string{"lb3"}
mdrs := map[string]*cloudwatch.MetricDataResult{ mdrs := map[string]*cloudwatch.MetricDataResult{
"lb3": { "lb3": {
Id: aws.String("lb3"), Id: aws.String("lb3"),
Label: aws.String("lb3"), Label: aws.String("lb3"),
Timestamps: []*time.Time{ Timestamps: []*time.Time{
aws.Time(timestamp), aws.Time(timestamp),
aws.Time(timestamp.Add(60 * time.Second)), aws.Time(timestamp.Add(60 * time.Second)),
aws.Time(timestamp.Add(180 * time.Second)), aws.Time(timestamp.Add(180 * time.Second)),
},
Values: []*float64{},
StatusCode: aws.String("Complete"),
}, },
} Values: []*float64{},
StatusCode: aws.String("Complete"),
},
}
query := &cloudWatchQuery{ query := &cloudWatchQuery{
RefId: "refId1", RefId: "refId1",
Region: "us-east-1", Region: "us-east-1",
Namespace: "AWS/ApplicationELB", Namespace: "AWS/ApplicationELB",
MetricName: "TargetResponseTime", MetricName: "TargetResponseTime",
Dimensions: map[string][]string{ Dimensions: map[string][]string{
"LoadBalancer": {"lb1", "lb2"}, "LoadBalancer": {"lb1", "lb2"},
"InstanceType": {"micro"}, },
"Resource": {"res"}, Stats: "Average",
Period: 60,
Alias: "{{LoadBalancer}} Expanded",
}
series, partialData, err := parseGetMetricDataTimeSeries(mdrs, labels, query)
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)
})
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{
"lb3": {
Id: aws.String("lb3"),
Label: aws.String("lb3"),
Timestamps: []*time.Time{
aws.Time(timestamp),
aws.Time(timestamp.Add(60 * time.Second)),
aws.Time(timestamp.Add(180 * time.Second)),
}, },
Stats: "Average", Values: []*float64{},
Period: 60, StatusCode: aws.String("Complete"),
Alias: "{{LoadBalancer}} Expanded {{InstanceType}} - {{Resource}}", },
} }
series, partialData, err := parseGetMetricDataTimeSeries(mdrs, labels, query)
So(err, ShouldBeNil) query := &cloudWatchQuery{
So(partialData, ShouldBeFalse) RefId: "refId1",
So(len(*series), ShouldEqual, 2) Region: "us-east-1",
So((*series)[0].Name, ShouldEqual, "lb1 Expanded micro - res") Namespace: "AWS/ApplicationELB",
So((*series)[1].Name, ShouldEqual, "lb2 Expanded micro - res") MetricName: "TargetResponseTime",
}) Dimensions: map[string][]string{
"LoadBalancer": {"lb1", "lb2"},
"InstanceType": {"micro"},
"Resource": {"res"},
},
Stats: "Average",
Period: 60,
Alias: "{{LoadBalancer}} Expanded {{InstanceType}} - {{Resource}}",
}
series, partialData, err := parseGetMetricDataTimeSeries(mdrs, labels, query)
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) timestamp := time.Unix(0, 0)
labels := []string{"lb"} labels := []string{"lb"}
mdrs := map[string]*cloudwatch.MetricDataResult{ mdrs := map[string]*cloudwatch.MetricDataResult{
"lb": { "lb": {
Id: aws.String("id1"), Id: aws.String("id1"),
Label: aws.String("lb"), Label: aws.String("lb"),
Timestamps: []*time.Time{ Timestamps: []*time.Time{
aws.Time(timestamp), aws.Time(timestamp),
aws.Time(timestamp.Add(60 * time.Second)), aws.Time(timestamp.Add(60 * time.Second)),
aws.Time(timestamp.Add(180 * time.Second)), aws.Time(timestamp.Add(180 * time.Second)),
},
Values: []*float64{
aws.Float64(10),
aws.Float64(20),
aws.Float64(30),
},
StatusCode: aws.String("Complete"),
}, },
} Values: []*float64{
aws.Float64(10),
query := &cloudWatchQuery{ aws.Float64(20),
RefId: "refId1", aws.Float64(30),
Region: "us-east-1",
Namespace: "AWS/ApplicationELB",
MetricName: "TargetResponseTime",
Dimensions: map[string][]string{
"LoadBalancer": {"lb"},
"TargetGroup": {"tg"},
}, },
Stats: "Average", StatusCode: aws.String("Complete"),
Period: 60, },
Alias: "{{namespace}}_{{metric}}_{{stat}}", }
}
series, partialData, err := parseGetMetricDataTimeSeries(mdrs, labels, query)
timeSeries := (*series)[0]
So(err, ShouldBeNil) query := &cloudWatchQuery{
So(partialData, ShouldBeFalse) RefId: "refId1",
So(timeSeries.Name, ShouldEqual, "AWS/ApplicationELB_TargetResponseTime_Average") Region: "us-east-1",
So(timeSeries.Tags["LoadBalancer"], ShouldEqual, "lb") Namespace: "AWS/ApplicationELB",
So(timeSeries.Points[0][0].String(), ShouldEqual, null.FloatFrom(10.0).String()) MetricName: "TargetResponseTime",
So(timeSeries.Points[1][0].String(), ShouldEqual, null.FloatFrom(20.0).String()) Dimensions: map[string][]string{
So(timeSeries.Points[2][0].String(), ShouldEqual, null.FloatFromPtr(nil).String()) "LoadBalancer": {"lb"},
So(timeSeries.Points[3][0].String(), ShouldEqual, null.FloatFrom(30.0).String()) "TargetGroup": {"tg"},
}) },
Stats: "Average",
Period: 60,
Alias: "{{namespace}}_{{metric}}_{{stat}}",
}
series, partialData, err := parseGetMetricDataTimeSeries(mdrs, labels, query)
timeSeries := (*series)[0]
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