[k8s] Properly parse the kubernetes' errors.StatusError type (#349)

Have the k8s package properly parse the kubernetes' errors.StatusError
type if returned and return a `*k8s.ServerResponseError` wrapping it.
Add tests for error parsing. Resolves
#301

---------

Co-authored-by: Igor Suleymanov <radiohead@users.noreply.github.com>

Author: IfSentient

k8s/gvclient.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net/http"
 	"strconv"
@@ -14,6 +15,7 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
 	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/codes"
+	k8serrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/watch"
@@ -555,11 +557,23 @@ type k8sErrBody struct {
 // Ths method will parse the response body for a better error message if available, and return a *ServerResponseError
 // if the status code is a non-success (>= 300).
 func parseKubernetesError(responseBytes []byte, statusCode int, err error) error {
+	if err != nil {
+		statusErr := &k8serrors.StatusError{}
+		if errors.As(err, &statusErr) {
+			if statusCode == 0 || (statusErr.ErrStatus.Code > 0 && statusCode != int(statusErr.ErrStatus.Code)) {
+				return NewServerResponseError(statusErr, int(statusErr.ErrStatus.Code))
+			}
+			return NewServerResponseError(statusErr, statusCode)
+		}
+	}
 	if len(responseBytes) > 0 {
 		parsed := k8sErrBody{}
 		// If we can parse the response body, use the error contained there instead, because it's clearer
 		if e := json.Unmarshal(responseBytes, &parsed); e == nil {
 			err = fmt.Errorf(parsed.Message)
+			if statusCode == 0 && parsed.Code > 0 {
+				statusCode = parsed.Code
+			}
 		}
 	}
 	// HTTP error?

k8s/gvclient_test.go

@@ -0,0 +1,88 @@
+package k8s
+
+import (
+	"fmt"
+	"net/http"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	k8serrors "k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+func TestParseKubernetesError(t *testing.T) {
+	tests := []struct {
+		name        string
+		bytes       []byte
+		statusCode  int
+		err         error
+		expectedErr error
+	}{{
+		name:       "status error",
+		bytes:      nil,
+		statusCode: 0,
+		err: &k8serrors.StatusError{
+			ErrStatus: metav1.Status{
+				Message: "I AM ERROR",
+				Code:    http.StatusInternalServerError,
+			},
+		},
+		expectedErr: NewServerResponseError(&k8serrors.StatusError{
+			ErrStatus: metav1.Status{
+				Message: "I AM ERROR",
+				Code:    http.StatusInternalServerError,
+			},
+		}, http.StatusInternalServerError),
+	}, {
+		name:       "status error, code conflicts with returned response code",
+		bytes:      nil,
+		statusCode: http.StatusConflict,
+		err: &k8serrors.StatusError{
+			ErrStatus: metav1.Status{
+				Message: "I AM ERROR",
+				Code:    http.StatusInternalServerError,
+			},
+		},
+		expectedErr: NewServerResponseError(&k8serrors.StatusError{
+			ErrStatus: metav1.Status{
+				Message: "I AM ERROR",
+				Code:    http.StatusInternalServerError,
+			},
+		}, http.StatusInternalServerError),
+	}, {
+		name:       "status error, code conflicts with returned response code (status.Code 0)",
+		bytes:      nil,
+		statusCode: http.StatusConflict,
+		err: &k8serrors.StatusError{
+			ErrStatus: metav1.Status{
+				Message: "I AM ERROR",
+			},
+		},
+		expectedErr: NewServerResponseError(&k8serrors.StatusError{
+			ErrStatus: metav1.Status{
+				Message: "I AM ERROR",
+			},
+		}, http.StatusConflict),
+	}, {
+		name:        "other error type, body JSON",
+		bytes:       []byte(`{"code":404,"message":"no way"}`),
+		err:         fmt.Errorf("no way"),
+		expectedErr: NewServerResponseError(fmt.Errorf("no way"), http.StatusNotFound),
+	}, {
+		name:        "other error type, body JSON, no status code",
+		bytes:       []byte(`{"message":"no way"}`),
+		err:         fmt.Errorf("no way 2"),
+		expectedErr: fmt.Errorf("no way"),
+	}, {
+		name:        "other error type, no body JSON",
+		err:         fmt.Errorf("nope"),
+		expectedErr: fmt.Errorf("nope"),
+	}}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			err := parseKubernetesError(test.bytes, test.statusCode, test.err)
+			assert.Equal(t, test.expectedErr, err)
+		})
+	}
+}