fix: convert unnamed errors to types

Author: arnecls

admissionrequesthook.go

@@ -4,7 +4,6 @@
 package kubernetes
 
 import (
-	"fmt"
 	"net/http"
 
 	"github.com/gin-gonic/gin"
@@ -38,11 +37,11 @@ func (h AdmissionRequestHook) Call(req *admission.AdmissionRequest) (ValidationR
 	case admission.Delete:
 		callback = h.Delete
 	default:
-		return ValidationOk, fmt.Errorf("unknown admission operation: %s", req.Operation)
+		return ValidationOk, ErrUnknownOperation(string(req.Operation))
 	}
 
 	if callback == nil {
-		return ValidationOk, fmt.Errorf("operation %s has no callback set", req.Operation)
+		return ValidationOk, ErrNoCallback(string(req.Operation))
 	}
 
 	// TODO: create parse request here

errors.go

@@ -90,8 +90,100 @@ func (e ErrIncorrectType) Error() string {
 //
 // Array modification operations must use "-" for appending; explicit indices are not
 // supported during path extension.
-type ErrIndexNotation string
+type ErrIndexNotation struct{}
 
 func (e ErrIndexNotation) Error() string {
 	return "Cannot append to array using index notation"
 }
+
+// ErrNoData is returned when a RawExtension object does not contain any data.
+// This occurs when both the Raw and Object fields are nil during conversion from
+// a runtime.RawExtension to a NamedObject.
+type ErrNoData struct{}
+
+func (e ErrNoData) Error() string {
+	return "No data found in raw object"
+}
+
+// ErrMissingName is returned when a Kubernetes object does not have a name or
+// generateName field set in its metadata. This occurs during object validation
+// in NamedObjectFromUnstructured when neither metadata.name nor metadata.generateName
+// is present. All Kubernetes objects must have at least one of these fields defined.
+type ErrMissingName struct{}
+
+func (e ErrMissingName) Error() string {
+	return "Object does not have a name set"
+}
+
+// ErrUnsupportedHashType is returned when attempting to hash a field with a type
+// that is not supported by the hashing algorithm. This occurs when:
+//   - A field type cannot be converted to a hashable representation
+//   - An unknown or complex type is encountered during object hashing
+//
+// The error string contains the field name and its type information.
+type ErrUnsupportedHashType string
+
+func (e ErrUnsupportedHashType) Error() string {
+	return string(e)
+}
+
+// ErrUnknownOperation is returned when an admission webhook receives a request
+// with an operation type that is not recognized. Valid operations are Create,
+// Update, and Delete. This error occurs in AdmissionRequestHook.Call when the
+// admission request contains an unsupported operation.
+//
+// The error string contains the unknown operation name.
+type ErrUnknownOperation string
+
+func (e ErrUnknownOperation) Error() string {
+	return fmt.Sprintf("Unknown admission operation: %s", string(e))
+}
+
+// ErrNoCallback is returned when an admission webhook receives a request for an
+// operation that does not have a validation callback registered. This occurs in
+// AdmissionRequestHook.Call when the operation (Create, Update, or Delete) handler
+// is nil. The request is still marked as validated to avoid blocking operations.
+//
+// The error string contains the operation name that lacks a callback.
+type ErrNoCallback string
+
+func (e ErrNoCallback) Error() string {
+	return fmt.Sprintf("Operation %s has no callback set", string(e))
+}
+
+// ErrInvalidBoundObjectRef is returned when attempting to create a service account
+// token with an invalid bound object reference. This occurs when:
+//   - A bound object reference is provided but is not a Pod
+//   - The Kind field is set to something other than "pod" (case-insensitive)
+//
+// Service account tokens can only be bound to Pod objects or have no binding.
+type ErrInvalidBoundObjectRef struct{}
+
+func (e ErrInvalidBoundObjectRef) Error() string {
+	return "Bound object reference must be a pod or nil"
+}
+
+// ErrNoToken is returned when a service account token request succeeds but the
+// response does not contain a token. This occurs in GetServiceAccountToken when
+// the Kubernetes API returns a successful response with an empty token field,
+// indicating an unexpected API behavior.
+type ErrNoToken struct{}
+
+func (e ErrNoToken) Error() string {
+	return "No token in server response"
+}
+
+// ErrParseError is returned when parsing label selector components fails due to
+// type mismatches. This occurs in ParseLabelSelector when:
+//   - A selector value is not a string
+//   - matchLabels is not a map[string]string or map[string]interface{}
+//   - matchExpressions is not the expected slice type
+//   - A matchExpressions element is not a map[string]interface{}
+//   - Required fields (key, operator, values) are not of the expected type
+//
+// The error string contains details about what failed to parse and the actual value.
+type ErrParseError string
+
+func (e ErrParseError) Error() string {
+	return string(e)
+}

labelselector.go

@@ -39,7 +39,7 @@ func ParseLabelSelector(obj map[string]interface{}) (metav1.LabelSelector, error
 		for k, v := range obj {
 			stringValue, ok := v.(string)
 			if !ok {
-				return selector, fmt.Errorf("failed to parse selector[%s] as string : %v", k, v)
+				return selector, ErrParseError(fmt.Sprintf("failed to parse selector[%s] as string : %v", k, v))
 			}
 			selector.MatchLabels[k] = stringValue
 		}
@@ -52,14 +52,14 @@ func ParseLabelSelector(obj map[string]interface{}) (metav1.LabelSelector, error
 			// Support any-type key/value maps (named objects)
 			untyped, ok := matchLabels.(map[string]interface{})
 			if !ok {
-				return selector, fmt.Errorf("failed to parse matchLabels as map[string]string or map[string]interface{} : %v", matchLabels)
+				return selector, ErrParseError(fmt.Sprintf("failed to parse matchLabels as map[string]string or map[string]interface{} : %v", matchLabels))
 			}
 
 			selector.MatchLabels = make(map[string]string)
 			for k, v := range untyped {
 				stringValue, ok := v.(string)
 				if !ok {
-					return selector, fmt.Errorf("failed to parse matchLabels[%s] as string : %v", k, v)
+					return selector, ErrParseError(fmt.Sprintf("failed to parse matchLabels[%s] as string : %v", k, v))
 				}
 				selector.MatchLabels[k] = stringValue
 			}
@@ -72,14 +72,14 @@ func ParseLabelSelector(obj map[string]interface{}) (metav1.LabelSelector, error
 			// Support any-type key/value maps (named objects)
 			untypedList, ok := matchExpressions.([]interface{})
 			if !ok {
-				return selector, fmt.Errorf("failed to parse matchExpressions as []metav1.LabelSelectorRequirement or []interface{} : %v", matchExpressions)
+				return selector, ErrParseError(fmt.Sprintf("failed to parse matchExpressions as []metav1.LabelSelectorRequirement or []interface{} : %v", matchExpressions))
 			}
 
 			selector.MatchExpressions = make([]metav1.LabelSelectorRequirement, 0, len(untypedList))
 			for i, v := range untypedList {
 				untypedMap, ok := v.(map[string]interface{})
 				if !ok {
-					return selector, fmt.Errorf("failed to parse matchExpressions[%d] as map[string]interface{} : %v", i, v)
+					return selector, ErrParseError(fmt.Sprintf("failed to parse matchExpressions[%d] as map[string]interface{} : %v", i, v))
 				}
 
 				parsed, err := parseLabelSelectorRequirement(untypedMap)
@@ -104,27 +104,27 @@ func parseLabelSelectorRequirement(obj map[string]interface{}) (metav1.LabelSele
 
 	req.Key, ok = obj["key"].(string)
 	if !ok {
-		return req, fmt.Errorf("failed to parse key as string : %v", obj["key"])
+		return req, ErrParseError(fmt.Sprintf("failed to parse key as string : %v", obj["key"]))
 	}
 
 	operatorStr, ok := obj["operator"].(string)
 	if !ok {
-		return req, fmt.Errorf("failed to parse operator as metav1.LabelSelectorOperator (string) : %v", obj["operator"])
+		return req, ErrParseError(fmt.Sprintf("failed to parse operator as metav1.LabelSelectorOperator (string) : %v", obj["operator"]))
 	}
 	req.Operator = metav1.LabelSelectorOperator(operatorStr)
 
 	req.Values, ok = obj["values"].([]string)
 	if !ok {
 		untypedList, ok := obj["values"].([]interface{})
 		if !ok {
-			return req, fmt.Errorf("failed to parse values as []string or []interface{} : %v", obj["values"])
+			return req, ErrParseError(fmt.Sprintf("failed to parse values as []string or []interface{} : %v", obj["values"]))
 		}
 
 		req.Values = make([]string, 0, len(untypedList))
 		for i, v := range untypedList {
 			stringValue, ok := v.(string)
 			if !ok {
-				return req, fmt.Errorf("failed to parse values[%d] as string : %v", i, v)
+				return req, ErrParseError(fmt.Sprintf("failed to parse values[%d] as string : %v", i, v))
 			}
 
 			req.Values = append(req.Values, stringValue)

namedobject.go

@@ -38,7 +38,7 @@ func NewNamedObject(name string) NamedObject {
 func NamedObjectFromRaw(data *runtime.RawExtension) (NamedObject, error) {
 	if data.Raw == nil {
 		if data.Object == nil {
-			return NamedObject{}, fmt.Errorf("no data found in raw object")
+			return NamedObject{}, ErrNoData{}
 		}
 		var err error
 		if data.Raw, err = jsoniter.Marshal(data.Object); err != nil {
@@ -67,7 +67,7 @@ func NamedObjectFromUnstructured(unstructuredObj unstructured.Unstructured) (Nam
 	// "generateName" is used by pods before a, e.g., ReplicaSet controler
 	// processed the pod.
 	if !obj.Has(PathMetadataName) && !obj.Has(PathMetadataGenerateName) {
-		return obj, fmt.Errorf("object does not have a name set")
+		return obj, ErrMissingName{}
 	}
 
 	return obj, nil
@@ -537,7 +537,7 @@ func doHash(hasher hash.Hash64, k string, iv interface{}) error {
 		return err
 
 	default:
-		return fmt.Errorf("cannot create hash for field %s of type %T", k, v)
+		return ErrUnsupportedHashType(fmt.Sprintf("cannot create hash for field %s of type %T", k, v))
 	}
 }
 
@@ -608,7 +608,7 @@ func (obj NamedObject) GeneratePatch(path Path, value interface{}) (Path, interf
 		}
 
 	case ArrayNotationIndex:
-		return validPath, value, ErrIndexNotation("")
+		return validPath, value, ErrIndexNotation{}
 	}
 
 	extendedValue := parentNode
@@ -660,7 +660,7 @@ func (obj NamedObject) GeneratePatch(path Path, value interface{}) (Path, interf
 			}
 
 		case ArrayNotationIndex:
-			return validPath, value, ErrIndexNotation("")
+			return validPath, value, ErrIndexNotation{}
 		}
 	}