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

* 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>

pkg/tsdb/cloudwatch/cloudwatch_query_test.go

@@ -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() {
-		Convey("and SEARCH(someexpression) was specified in the query editor", func() {
-			query := &cloudWatchQuery{
-				RefId:      "A",
-				Region:     "us-east-1",
-				Expression: "SEARCH(someexpression)",
-				Stats:      "Average",
-				Period:     300,
-				Id:         "id1",
-			}
-
-			Convey("it is a search expression", func() {
-				So(query.isSearchExpression(), ShouldBeTrue)
-			})
-
-			Convey("it is not math expressions", func() {
-				So(query.isMathExpression(), ShouldBeFalse)
-			})
-		})
+	t.Run("SEARCH(someexpression) was specified in the query editor", func(t *testing.T) {
+		query := &cloudWatchQuery{
+			RefId:      "A",
+			Region:     "us-east-1",
+			Expression: "SEARCH(someexpression)",
+			Stats:      "Average",
+			Period:     300,
+			Id:         "id1",
+		}
+
+		assert.True(t, query.isSearchExpression(), "Expected a search expression")
+		assert.False(t, query.isMathExpression(), "Expected not math expression")
+	})
 
 
-		Convey("and no expression, no multi dimension key values and no * was used", func() {
-			query := &cloudWatchQuery{
-				RefId:      "A",
-				Region:     "us-east-1",
-				Expression: "",
-				Stats:      "Average",
-				Period:     300,
-				Id:         "id1",
-				MatchExact: true,
-				Dimensions: map[string][]string{
-					"InstanceId": {"i-12345678"},
-				},
-			}
-
-			Convey("it is not a search expression", func() {
-				So(query.isSearchExpression(), ShouldBeFalse)
-			})
-
-			Convey("it is not math expressions", func() {
-				So(query.isMathExpression(), ShouldBeFalse)
-			})
-		})
+	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",
+			Expression: "",
+			Stats:      "Average",
+			Period:     300,
+			Id:         "id1",
+			MatchExact: true,
+			Dimensions: map[string][]string{
+				"InstanceId": {"i-12345678"},
+			},
+		}
+
+		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() {
-			query := &cloudWatchQuery{
-				RefId:      "A",
-				Region:     "us-east-1",
-				Expression: "",
-				Stats:      "Average",
-				Period:     300,
-				Id:         "id1",
-				Dimensions: map[string][]string{
-					"InstanceId": {"i-12345678", "i-34562312"},
-				},
-			}
-
-			Convey("it is a search expression", func() {
-				So(query.isSearchExpression(), ShouldBeTrue)
-			})
-
-			Convey("it is not math expressions", func() {
-				So(query.isMathExpression(), ShouldBeFalse)
-			})
-		})
+	t.Run("No expression but multi dimension key values exist", func(t *testing.T) {
+		query := &cloudWatchQuery{
+			RefId:      "A",
+			Region:     "us-east-1",
+			Expression: "",
+			Stats:      "Average",
+			Period:     300,
+			Id:         "id1",
+			Dimensions: map[string][]string{
+				"InstanceId": {"i-12345678", "i-34562312"},
+			},
+		}
+
+		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() {
-			query := &cloudWatchQuery{
-				RefId:      "A",
-				Region:     "us-east-1",
-				Expression: "",
-				Stats:      "Average",
-				Period:     300,
-				Id:         "id1",
-				Dimensions: map[string][]string{
-					"InstanceId":   {"i-12345678", "*"},
-					"InstanceType": {"abc", "def"},
-				},
-			}
-
-			Convey("it is not a search expression", func() {
-				So(query.isSearchExpression(), ShouldBeTrue)
-			})
-
-			Convey("it is not math expressions", func() {
-				So(query.isMathExpression(), ShouldBeFalse)
-			})
-		})
+	t.Run("No expression but dimension values has *", func(t *testing.T) {
+		query := &cloudWatchQuery{
+			RefId:      "A",
+			Region:     "us-east-1",
+			Expression: "",
+			Stats:      "Average",
+			Period:     300,
+			Id:         "id1",
+			Dimensions: map[string][]string{
+				"InstanceId":   {"i-12345678", "*"},
+				"InstanceType": {"abc", "def"},
+			},
+		}
+
+		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() {
-			query := &cloudWatchQuery{
-				RefId:      "A",
-				Region:     "us-east-1",
-				Expression: "",
-				Stats:      "Average",
-				Period:     300,
-				Id:         "id1",
-				Dimensions: map[string][]string{
-					"InstanceId":   {"i-12345678", "i-12345679"},
-					"InstanceType": {"abc"},
-				},
-			}
-
-			Convey("it is a search expression", func() {
-				So(query.isSearchExpression(), ShouldBeTrue)
-			})
-
-			Convey("it is a multi-valued dimension expression", func() {
-				So(query.isMultiValuedDimensionExpression(), ShouldBeTrue)
-			})
-		})
+	t.Run("Query has a multi-valued dimension", func(t *testing.T) {
+		query := &cloudWatchQuery{
+			RefId:      "A",
+			Region:     "us-east-1",
+			Expression: "",
+			Stats:      "Average",
+			Period:     300,
+			Id:         "id1",
+			Dimensions: map[string][]string{
+				"InstanceId":   {"i-12345678", "i-12345679"},
+				"InstanceType": {"abc"},
+			},
+		}
+
+		assert.True(t, query.isSearchExpression(), "Expected a search expression")
+		assert.True(t, query.isMultiValuedDimensionExpression(), "Expected a multi-valued dimension expression")
+	})
 
 
-		Convey("and no dimensions were added", func() {
-			query := &cloudWatchQuery{
-				RefId:      "A",
-				Region:     "us-east-1",
-				Expression: "",
-				Stats:      "Average",
-				Period:     300,
-				Id:         "id1",
-				MatchExact: false,
-				Dimensions: make(map[string][]string),
-			}
-			Convey("and match exact is false", func() {
-				query.MatchExact = false
-				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)
-				})
-			})
-
-			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)
-				})
-			})
+	t.Run("No dimensions were added", func(t *testing.T) {
+		query := &cloudWatchQuery{
+			RefId:      "A",
+			Region:     "us-east-1",
+			Expression: "",
+			Stats:      "Average",
+			Period:     300,
+			Id:         "id1",
+			MatchExact: false,
+			Dimensions: make(map[string][]string),
+		}
+		t.Run("Match exact is false", func(t *testing.T) {
+			query.MatchExact = false
+			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("and match exact is", func() {
-			query := &cloudWatchQuery{
-				RefId:      "A",
-				Region:     "us-east-1",
-				Expression: "",
-				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 true", func(t *testing.T) {
+			query.MatchExact = true
+			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")
 		})
 		})
 	})
 	})
+
+	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")
+	})
 }
 }

pkg/tsdb/cloudwatch/query_transformer_test.go

@@ -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() {
-		Convey("when transforming queries", func() {
-			executor := newExecutor()
-			Convey("one cloudwatchQuery is generated when its request query has one stat", func() {
-				requestQueries := []*requestQuery{
-					{
-						RefId:      "D",
-						Region:     "us-east-1",
-						Namespace:  "ec2",
-						MetricName: "CPUUtilization",
-						Statistics: aws.StringSlice([]string{"Average"}),
-						Period:     600,
-						Id:         "",
-					},
-				}
+	executor := newExecutor()
+	t.Run("One cloudwatchQuery is generated when its request query has one stat", func(t *testing.T) {
+		requestQueries := []*requestQuery{
+			{
+				RefId:      "D",
+				Region:     "us-east-1",
+				Namespace:  "ec2",
+				MetricName: "CPUUtilization",
+				Statistics: aws.StringSlice([]string{"Average"}),
+				Period:     600,
+				Id:         "",
+			},
+		}
 
 
-				res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
-				So(err, ShouldBeNil)
-				So(len(res), ShouldEqual, 1)
-			})
+		res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
+		require.NoError(t, err)
+		assert.Len(t, res, 1)
+	})
 
 
-			Convey("two cloudwatchQuery is generated when there's two stats", func() {
-				requestQueries := []*requestQuery{
-					{
-						RefId:      "D",
-						Region:     "us-east-1",
-						Namespace:  "ec2",
-						MetricName: "CPUUtilization",
-						Statistics: aws.StringSlice([]string{"Average", "Sum"}),
-						Period:     600,
-						Id:         "",
-					},
-				}
+	t.Run("Two cloudwatchQuery is generated when there's two stats", func(t *testing.T) {
+		requestQueries := []*requestQuery{
+			{
+				RefId:      "D",
+				Region:     "us-east-1",
+				Namespace:  "ec2",
+				MetricName: "CPUUtilization",
+				Statistics: aws.StringSlice([]string{"Average", "Sum"}),
+				Period:     600,
+				Id:         "",
+			},
+		}
 
 
-				res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
-				So(err, ShouldBeNil)
-				So(len(res), ShouldEqual, 2)
-			})
-			Convey("and id is given by user", func() {
-				Convey("that id will be used in the cloudwatch query", func() {
-					requestQueries := []*requestQuery{
-						{
-							RefId:      "D",
-							Region:     "us-east-1",
-							Namespace:  "ec2",
-							MetricName: "CPUUtilization",
-							Statistics: aws.StringSlice([]string{"Average"}),
-							Period:     600,
-							Id:         "myid",
-						},
-					}
+		res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
+		require.NoError(t, err)
+		assert.Len(t, res, 2)
+	})
+	t.Run("id is given by user that will be used in the cloudwatch query", func(t *testing.T) {
+		requestQueries := []*requestQuery{
+			{
+				RefId:      "D",
+				Region:     "us-east-1",
+				Namespace:  "ec2",
+				MetricName: "CPUUtilization",
+				Statistics: aws.StringSlice([]string{"Average"}),
+				Period:     600,
+				Id:         "myid",
+			},
+		}
 
 
-					res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
-					So(err, ShouldBeNil)
-					So(len(res), ShouldEqual, 1)
-					So(res, ShouldContainKey, "myid")
-				})
-			})
+		res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
+		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() {
-					requestQueries := []*requestQuery{
-						{
-							RefId:      "D",
-							Region:     "us-east-1",
-							Namespace:  "ec2",
-							MetricName: "CPUUtilization",
-							Statistics: aws.StringSlice([]string{"Average"}),
-							Period:     600,
-							Id:         "",
-						},
-					}
+	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",
+					Region:     "us-east-1",
+					Namespace:  "ec2",
+					MetricName: "CPUUtilization",
+					Statistics: aws.StringSlice([]string{"Average"}),
+					Period:     600,
+					Id:         "",
+				},
+			}
 
 
-					res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
-					So(err, ShouldBeNil)
-					So(len(res), ShouldEqual, 1)
-					So(res, ShouldContainKey, "queryD")
-				})
+			res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
+			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() {
-					requestQueries := []*requestQuery{
-						{
-							RefId:      "D",
-							Region:     "us-east-1",
-							Namespace:  "ec2",
-							MetricName: "CPUUtilization",
-							Statistics: aws.StringSlice([]string{"Average", "Sum"}),
-							Period:     600,
-							Id:         "",
-						},
-					}
+		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",
+					Region:     "us-east-1",
+					Namespace:  "ec2",
+					MetricName: "CPUUtilization",
+					Statistics: aws.StringSlice([]string{"Average", "Sum"}),
+					Period:     600,
+					Id:         "",
+				},
+			}
 
 
-					res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
-					So(err, ShouldBeNil)
-					So(len(res), ShouldEqual, 2)
-					So(res, ShouldContainKey, "queryD_Sum")
-					So(res, ShouldContainKey, "queryD_Average")
-				})
-			})
+			res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
+			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() {
-				requestQueries := []*requestQuery{
-					{
-						RefId:      "D",
-						Region:     "us-east-1",
-						Namespace:  "ec2",
-						MetricName: "CPUUtilization",
-						Statistics: aws.StringSlice([]string{"Average", "p46.32"}),
-						Period:     600,
-						Id:         "",
-					},
-				}
+	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",
+				Region:     "us-east-1",
+				Namespace:  "ec2",
+				MetricName: "CPUUtilization",
+				Statistics: aws.StringSlice([]string{"Average", "p46.32"}),
+				Period:     600,
+				Id:         "",
+			},
+		}
 
 
-				res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
-				So(err, ShouldBeNil)
-				So(len(res), ShouldEqual, 2)
-				So(res, ShouldContainKey, "queryD_p46_32")
-			})
+		res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
+		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() {
-				requestQueries := []*requestQuery{
-					{
-						RefId:      "D",
-						Region:     "us-east-1",
-						Namespace:  "ec2",
-						MetricName: "CPUUtilization",
-						Statistics: aws.StringSlice([]string{"Average", "p46.32"}),
-						Period:     600,
-						Id:         "myId",
-					},
-					{
-						RefId:      "E",
-						Region:     "us-east-1",
-						Namespace:  "ec2",
-						MetricName: "CPUUtilization",
-						Statistics: aws.StringSlice([]string{"Average", "p46.32"}),
-						Period:     600,
-						Id:         "myId",
-					},
-				}
+	t.Run("should return an error if two queries have the same id", func(t *testing.T) {
+		requestQueries := []*requestQuery{
+			{
+				RefId:      "D",
+				Region:     "us-east-1",
+				Namespace:  "ec2",
+				MetricName: "CPUUtilization",
+				Statistics: aws.StringSlice([]string{"Average", "p46.32"}),
+				Period:     600,
+				Id:         "myId",
+			},
+			{
+				RefId:      "E",
+				Region:     "us-east-1",
+				Namespace:  "ec2",
+				MetricName: "CPUUtilization",
+				Statistics: aws.StringSlice([]string{"Average", "p46.32"}),
+				Period:     600,
+				Id:         "myId",
+			},
+		}
 
 
-				res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
-				So(res, ShouldBeNil)
-				So(err, ShouldNotBeNil)
-			})
-		})
+		res, err := executor.transformRequestQueriesToCloudWatchQueries(requestQueries)
+		require.Nil(t, res)
+		assert.Error(t, err)
 	})
 	})
 }
 }