Move StreamError to pkg/errors

Allows library implementations of StreamClient and StreamClientFactory
to return fatal StreamErrors
Signed-off-by: Michael Stergianis <michaelstergianis@gmail.com>

internal/api/streaming_connection_errors.go

-package api
-
-type StreamError struct {
-	error
-	Fatal bool
-}
-
-func FatalStreamError(err error) error {
-	return StreamError{
-		err,
-		true,
-	}
-}
-
-func IsFatalStreamError(err error) bool {
-	sErr, ok := err.(StreamError)
-	if !ok {
-		return false
-	}
-
-	return sErr.Fatal
-}

internal/api/websocket_client.go

@@ -12,6 +12,7 @@ import (
 	"time"
 
 	"github.com/vmware-tanzu/octant/internal/util/json"
+	"github.com/vmware-tanzu/octant/pkg/errors"
 
 	"github.com/vmware-tanzu/octant/pkg/event"
 
@@ -168,7 +169,7 @@ func (c *WebsocketClient) readPump() {
 	for {
 		request, err := c.Receive()
 		if err != nil {
-			if IsFatalStreamError(err) {
+			if errors.IsFatalStreamError(err) {
 				c.cancel()
 				break
 			}
@@ -293,7 +294,7 @@ func (c *WebsocketClient) Receive() (StreamRequest, error) {
 		) {
 			c.logger.WithErr(err).Errorf("Unhandled websocket error")
 		}
-		return StreamRequest{}, FatalStreamError(err)
+		return StreamRequest{}, errors.FatalStreamError(err)
 	}
 
 	var request StreamRequest

pkg/errors/streaming_connection_error.go

+package errors
+
+import "github.com/vmware-tanzu/octant/internal/errors"
+
+type StreamError struct {
+	*errors.GenericError
+	Fatal bool
+}
+
+func NewStreamError(err error) *StreamError {
+	return &StreamError{
+		errors.NewGenericError(err),
+		false,
+	}
+}
+
+func FatalStreamError(err error) *StreamError {
+	return &StreamError{
+		errors.NewGenericError(err),
+		true,
+	}
+}
+
+func IsFatalStreamError(err error) bool {
+	switch sErr := err.(type) {
+	case StreamError:
+		return sErr.Fatal
+	case *StreamError:
+		return sErr.Fatal
+	default:
+		return false
+	}
+}
+
+const StreamingConnectionError = "StreamingConnectionError"
+
+func (s *StreamError) Name() string {
+	return StreamingConnectionError
+}

pkg/errors/streaming_connection_error_test.go

+package errors
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestConstructors(t *testing.T) {
+	err := fmt.Errorf("encountered an error while streaming")
+	table := []struct {
+		name  string
+		sErr  *StreamError
+		fatal bool
+	}{
+		{"NewStreamError", NewStreamError(err), false},
+		{"FatalStreamError", FatalStreamError(err), true},
+	}
+
+	for _, test := range table {
+		t.Run(test.name, func(t *testing.T) {
+			assert.NotEmpty(t, test.sErr.Timestamp())
+			assert.Equal(t, test.sErr.Name(), StreamingConnectionError)
+			assert.NotZero(t, test.sErr.ID())
+			assert.Equal(t, test.fatal, test.sErr.Fatal)
+			assert.Equal(t, err.Error(), test.sErr.Error())
+		})
+	}
+}
+
+func TestIsFatalStreamError(t *testing.T) {
+	table := []struct {
+		name     string
+		sErr     error
+		expected bool
+	}{
+		{
+			"Expect IsFatalStreamError to be false for a standard stream error",
+			NewStreamError(fmt.Errorf("")),
+			false,
+		},
+		{
+			"Expect IsFatalStreamError to be true for fatal stream error",
+			FatalStreamError(fmt.Errorf("")),
+			true,
+		},
+		{
+			"A non pointer fatal stream error is provided",
+			*FatalStreamError(fmt.Errorf("")),
+			true,
+		},
+		{
+			"A generic error is provided",
+			fmt.Errorf(""),
+			false,
+		},
+	}
+
+	for _, test := range table {
+		t.Run(test.name, func(t *testing.T) {
+			assert.Equal(t, test.expected, IsFatalStreamError(test.sErr))
+		})
+	}
+}