ansible · thom-at-redhat · Jul 16, 2024< 8000 /relative-time> · Jul 15, 2024 · Jul 15, 2024 · Jul 15, 2024
diff --git a/pkg/utils/error_kind.go b/pkg/utils/error_kind.go
@@ -4,20 +4,20 @@ import "fmt"
 
 // ErrorWithKind represents an error wrapped with a designation of what kind of error it is.
 type ErrorWithKind struct {
-	err  error
-	kind string
+	Err  error
+	Kind string
 }
 
 // Error returns the error text as a string.
 func (ek ErrorWithKind) Error() string {
-	return fmt.Sprintf("%s error: %s", ek.kind, ek.err)
+	return fmt.Sprintf("%s error: %v", ek.Kind, ek.Err)
 }
 
 // WrapErrorWithKind creates an ErrorWithKind that wraps an underlying error.
 func WrapErrorWithKind(err error, kind string) ErrorWithKind {
 	return ErrorWithKind{
-		err:  err,
-		kind: kind,
+		Err:  err,
+		Kind: kind,
 	}
 }
 
@@ -28,5 +28,5 @@ func ErrorIsKind(err error, kind string) bool {
 		return false
 	}
 
-	return ek.kind == kind
+	return ek.Kind == kind
 }
diff --git a/pkg/utils/error_kind_test.go b/pkg/utils/error_kind_test.go
@@ -0,0 +1,137 @@
+package utils_test
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+
+	"github.com/ansible/receptor/pkg/utils"
+)
+
+const (
+	goodKind        string = "connection"
+	goodErrorString string = "unit was already started"
+)
+
+var errUnitWasAlreadyStarted error = fmt.Errorf(goodErrorString)
+
+func TestErrorWithKind_Error(t *testing.T) {
+	type fields struct {
+		err  error
+		kind string
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   string
+	}{
+		{
+			name: "Positive",
+			fields: fields{
+				err:  errUnitWasAlreadyStarted,
+				kind: goodKind,
+			},
+			want: fmt.Sprintf("%s error: %s", goodKind, goodErrorString),
+		},
+		{
+			name: "Negative",
+			fields: fields{
+				err:  nil,
+				kind: goodKind,
+			},
+			want: fmt.Sprintf("%s error: <nil>", goodKind),
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ek := utils.ErrorWithKind{
+				Err:  tt.fields.err,
+				Kind: tt.fields.kind,
+			}
+			if got := ek.Error(); got != tt.want {
+				t.Errorf("ErrorWithKind.Error() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestWrapErrorWithKind(t *testing.T) {
+	type args struct {
+		err  error
+		kind string
+	}
+	tests := []struct {
+		name string
+		args args
+		want utils.ErrorWithKind
+	}{
+		{
+			name: "Positive",
+			args: args{
+				err:  errUnitWasAlreadyStarted,
+				kind: goodKind,
+			},
+			want: utils.ErrorWithKind{
+				Err:  errUnitWasAlreadyStarted,
+				Kind: goodKind,
+			},
+		},
+		{
+			name: "Negative",
+			args: args{
+				err:  nil,
+				kind: goodKind,
+			},
+			want: utils.ErrorWithKind{
+				Err:  nil,
+				Kind: goodKind,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := utils.WrapErrorWithKind(tt.args.err, tt.args.kind); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("WrapErrorWithKind() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestErrorIsKind(t *testing.T) {
+	type args struct {
+		err  error
+		kind string
+	}
+	tests := []struct {
+		name string
+		args args
+		want bool
+	}{
+		{
+			name: "Positive",
+			args: args{
+				err: utils.WrapErrorWithKind(
+					errUnitWasAlreadyStarted,
+					goodKind,
+				),
+				kind: goodKind,
+			},
+			want: true,
+		},
+		{
+			name: "Negative",
+			args: args{
+				err:  nil,
+				kind: goodKind,
+			},
+			want: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := utils.ErrorIsKind(tt.args.err, tt.args.kind); got != tt.want {
+				t.Errorf("ErrorIsKind() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}