Chore: Rewrite models tags test to standard library (#30041)

pkg/models/tags_test.go

@@ -3,93 +3,94 @@ package models
 import (
 	"testing"
 
-	. "github.com/smartystreets/goconvey/convey"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
-func TestParsingTags(t *testing.T) {
+func TestParseTagPairs(t *testing.T) {
-	Convey("Testing parsing a tag pairs into tags", t, func() {
+	t.Run("Can parse one empty tag", func(t *testing.T) {
-		Convey("Can parse one empty tag", func() {
+		tags := ParseTagPairs([]string{""})
-			tags := ParseTagPairs([]string{""})
+		require.Empty(t, tags)
-			So(len(tags), ShouldEqual, 0)
+	})
-		})
 
-		Convey("Can parse valid tags", func() {
+	t.Run("Can parse valid tags", func(t *testing.T) {
-			tags := ParseTagPairs([]string{"outage", "type:outage", "error"})
+		tags := ParseTagPairs([]string{"outage", "type:outage", "error"})
-			So(len(tags), ShouldEqual, 3)
+		require.Len(t, tags, 3)
-			So(tags[0].Key, ShouldEqual, "outage")
+		assert.Equal(t, "outage", tags[0].Key)
-			So(tags[0].Value, ShouldEqual, "")
+		assert.Empty(t, tags[0].Value)
-			So(tags[1].Key, ShouldEqual, "type")
+		assert.Equal(t, "type", tags[1].Key)
-			So(tags[1].Value, ShouldEqual, "outage")
+		assert.Equal(t, "outage", tags[1].Value)
-			So(tags[2].Key, ShouldEqual, "error")
+		assert.Equal(t, "error", tags[2].Key)
-			So(tags[2].Value, ShouldEqual, "")
+		assert.Empty(t, tags[2].Value)
-		})
+	})
 
-		Convey("Can parse tags with spaces", func() {
+	t.Run("Can parse tags with spaces", func(t *testing.T) {
-			tags := ParseTagPairs([]string{" outage ", " type : outage ", "error "})
+		tags := ParseTagPairs([]string{" outage ", " type : outage ", "error "})
-			So(len(tags), ShouldEqual, 3)
+		require.Len(t, tags, 3)
-			So(tags[0].Key, ShouldEqual, "outage")
+		assert.Equal(t, "outage", tags[0].Key)
-			So(tags[0].Value, ShouldEqual, "")
+		assert.Empty(t, tags[0].Value)
-			So(tags[1].Key, ShouldEqual, "type")
+		assert.Equal(t, "type", tags[1].Key)
-			So(tags[1].Value, ShouldEqual, "outage")
+		assert.Equal(t, "outage", tags[1].Value)
-			So(tags[2].Key, ShouldEqual, "error")
+		assert.Equal(t, "error", tags[2].Key)
-			So(tags[2].Value, ShouldEqual, "")
+		assert.Empty(t, tags[2].Value)
-		})
+	})
 
-		Convey("Can parse empty tags", func() {
+	t.Run("Can parse empty tags", func(t *testing.T) {
-			tags := ParseTagPairs([]string{" outage ", "", "", ":", "type : outage ", "error ", "", ""})
+		tags := ParseTagPairs([]string{" outage ", "", "", ":", "type : outage ", "error ", "", ""})
-			So(len(tags), ShouldEqual, 3)
+		require.Len(t, tags, 3)
-			So(tags[0].Key, ShouldEqual, "outage")
+		assert.Equal(t, "outage", tags[0].Key)
-			So(tags[0].Value, ShouldEqual, "")
+		assert.Empty(t, tags[0].Value)
-			So(tags[1].Key, ShouldEqual, "type")
+		assert.Equal(t, "type", tags[1].Key)
-			So(tags[1].Value, ShouldEqual, "outage")
+		assert.Equal(t, "outage", tags[1].Value)
-			So(tags[2].Key, ShouldEqual, "error")
+		assert.Equal(t, "error", tags[2].Key)
-			So(tags[2].Value, ShouldEqual, "")
+		assert.Empty(t, tags[2].Value)
-		})
+	})
 
-		Convey("Can parse tags with extra colons", func() {
+	t.Run("Can parse tags with extra colons", func(t *testing.T) {
-			tags := ParseTagPairs([]string{" outage", "type : outage:outage2 :outage3 ", "error :"})
+		tags := ParseTagPairs([]string{" outage", "type : outage:outage2 :outage3 ", "error :"})
-			So(len(tags), ShouldEqual, 3)
+		require.Len(t, tags, 3)
-			So(tags[0].Key, ShouldEqual, "outage")
+		assert.Equal(t, "outage", tags[0].Key)
-			So(tags[0].Value, ShouldEqual, "")
+		assert.Empty(t, tags[0].Value)
-			So(tags[1].Key, ShouldEqual, "type")
+		assert.Equal(t, "type", tags[1].Key)
-			So(tags[1].Value, ShouldEqual, "outage")
+		assert.Equal(t, "outage", tags[1].Value)
-			So(tags[2].Key, ShouldEqual, "error")
+		assert.Equal(t, "error", tags[2].Key)
-			So(tags[2].Value, ShouldEqual, "")
+		assert.Empty(t, tags[2].Value)
-		})
+	})
 
-		Convey("Can parse tags that contains key and values with spaces", func() {
+	t.Run("Can parse tags that contains key and values with spaces", func(t *testing.T) {
-			tags := ParseTagPairs([]string{" outage 1", "type 1: outage 1 ", "has error "})
+		tags := ParseTagPairs([]string{" outage 1", "type 1: outage 1 ", "has error "})
-			So(len(tags), ShouldEqual, 3)
+		require.Len(t, tags, 3)
-			So(tags[0].Key, ShouldEqual, "outage 1")
+		assert.Equal(t, "outage 1", tags[0].Key)
-			So(tags[0].Value, ShouldEqual, "")
+		assert.Empty(t, tags[0].Value)
-			So(tags[1].Key, ShouldEqual, "type 1")
+		assert.Equal(t, "type 1", tags[1].Key)
-			So(tags[1].Value, ShouldEqual, "outage 1")
+		assert.Equal(t, "outage 1", tags[1].Value)
-			So(tags[2].Key, ShouldEqual, "has error")
+		assert.Equal(t, "has error", tags[2].Key)
-			So(tags[2].Value, ShouldEqual, "")
+		assert.Empty(t, tags[2].Value)
-		})
+	})
 
-		Convey("Can filter out duplicate tags", func() {
+	t.Run("Can filter out duplicate tags", func(t *testing.T) {
-			tags := ParseTagPairs([]string{"test", "test", "key:val1", "key:val2"})
+		tags := ParseTagPairs([]string{"test", "test", "key:val1", "key:val2"})
-			So(len(tags), ShouldEqual, 3)
+		require.Len(t, tags, 3)
-			So(tags[0].Key, ShouldEqual, "test")
+		assert.Equal(t, "test", tags[0].Key)
-			So(tags[0].Value, ShouldEqual, "")
+		assert.Empty(t, tags[0].Value)
-			So(tags[1].Key, ShouldEqual, "key")
+		assert.Equal(t, "key", tags[1].Key)
-			So(tags[1].Value, ShouldEqual, "val1")
+		assert.Equal(t, "val1", tags[1].Value)
-			So(tags[2].Key, ShouldEqual, "key")
+		assert.Equal(t, "key", tags[2].Key)
-			So(tags[2].Value, ShouldEqual, "val2")
+		assert.Equal(t, "val2", tags[2].Value)
-		})
+	})
-
+}
-		Convey("Can join tag pairs", func() {
+
-			tagPairs := []*Tag{
+func TestJoinTagPairs(t *testing.T) {
-				{Key: "key1", Value: "val1"},
+	t.Run("Can join tag pairs", func(t *testing.T) {
-				{Key: "key2", Value: ""},
+		tagPairs := []*Tag{
-				{Key: "key3"},
+			{Key: "key1", Value: "val1"},
-			}
+			{Key: "key2", Value: ""},
-			tags := JoinTagPairs(tagPairs)
+			{Key: "key3"},
-			So(len(tags), ShouldEqual, 3)
+		}
-			So(tags[0], ShouldEqual, "key1:val1")
+		tags := JoinTagPairs(tagPairs)
-			So(tags[1], ShouldEqual, "key2")
+		require.Len(t, tags, 3)
-			So(tags[2], ShouldEqual, "key3")
+		assert.Equal(t, "key1:val1", tags[0])
-		})
+		assert.Equal(t, "key2", tags[1])
+		assert.Equal(t, "key3", tags[2])
 	})
 }