[minor] added support for Join

Author: bnkamalesh

errors_test.go

@@ -134,10 +134,14 @@ func TestSetDefaultType(t *testing.T) {
 			wantErrType: TypeInputBody,
 		},
 	}
+
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
+			before := defaultErrType
 			SetDefaultType(tt.args.e)
 			err := New(tt.args.message)
+			// resetting to previous value to stop messing with the entire package
+			SetDefaultType(before)
 			if err.Type() != tt.wantErrType {
 				t.Errorf(
 					"New() = got type '%d', expected '%d",

helper.go

@@ -292,23 +292,38 @@ func DownstreamDependencyTimedoutErrf(original error, format string, args ...int
 }
 
 // HTTPStatusCodeMessage returns the appropriate HTTP status code, message, boolean for the error
-// the boolean value is true if the error was of type *Error, false otherwise
+// the boolean value is true if the error was of type *Error, false otherwise.
 func HTTPStatusCodeMessage(err error) (int, string, bool) {
-	derr, _ := err.(*Error)
-	if derr != nil {
-		return derr.HTTPStatusCode(), derr.Message(), true
+	code, isErr := HTTPStatusCode(err)
+	msg, isErrMsg := Message(err)
+	if msg == "" {
+		msg = err.Error()
 	}
-
-	return http.StatusInternalServerError, err.Error(), false
+	return code, msg, isErr && isErrMsg
 }
 
 // HTTPStatusCode returns appropriate HTTP response status code based on type of the error. The boolean
 // is 'true' if the provided error is of type *Err
+// In case of joined errors, it'll return the status code of the last *Error
 func HTTPStatusCode(err error) (int, bool) {
 	derr, _ := err.(*Error)
 	if derr != nil {
 		return derr.HTTPStatusCode(), true
 	}
+
+	jerr, _ := err.(*joinError)
+	if jerr != nil {
+		elen := len(jerr.errs)
+		isErr := true
+		for i := elen - 1; i >= 0; i-- {
+			code, isE := HTTPStatusCode(jerr.errs[i])
+			isErr = isE && isErr
+			if isE {
+				return code, isErr
+			}
+		}
+	}
+
 	return http.StatusInternalServerError, false
 }
 
@@ -325,6 +340,22 @@ func Message(err error) (string, bool) {
 	if derr != nil {
 		return derr.Message(), true
 	}
+
+	jerr, _ := err.(*joinError)
+	if jerr != nil {
+		list := make([]string, 0, len(jerr.errs))
+		isErr := true
+		for i := range jerr.errs {
+			msg, ok := Message(jerr.errs[i])
+			isErr = isErr && ok
+			if msg == "" {
+				continue
+			}
+			list = append(list, msg)
+		}
+		return strings.Join(list, "\n"), isErr
+	}
+
 	return "", false
 }
 
@@ -338,12 +369,23 @@ func WriteHTTP(err error, w http.ResponseWriter) {
 }
 
 // Type returns the errType if it's an instance of *Error, -1 otherwise
+// In case of joined error, it'll return the type of the last *Error
 func Type(err error) errType {
-	e, ok := err.(*Error)
-	if !ok {
-		return errType(-1)
+	e, _ := err.(*Error)
+	if e != nil {
+		return e.Type()
 	}
-	return e.Type()
+	je, _ := err.(*joinError)
+	if je != nil {
+		for i := len(je.errs) - 1; i >= 0; i-- {
+			et := Type(je.errs[i])
+			if et.Int() != -1 {
+				return et
+			}
+		}
+	}
+
+	return errType(-1)
 }
 
 // Type returns the errType as integer if it's an instance of *Error, -1 otherwise
@@ -362,6 +404,15 @@ func HasType(err error, et errType) bool {
 		return HasType(errors.Unwrap(err), et)
 	}
 
+	je, _ := err.(*joinError)
+	if je != nil {
+		for i := 0; i < len(je.errs); i++ {
+			if HasType(je.errs[i], et) {
+				return true
+			}
+		}
+	}
+
 	if e.Type() == et {
 		return true
 	}

helper_test.go

@@ -189,17 +189,17 @@ func TestHTTPStatusCodeMessage(t *testing.T) {
 			want2: true,
 		},
 	}
-	for _, tt := range tests {
+	for idx, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			got, got1, got2 := HTTPStatusCodeMessage(tt.args.err)
 			if got != tt.want {
-				t.Errorf("HTTPStatusCodeMessage() got = %v, want %v", got, tt.want)
+				t.Errorf("[%d] HTTPStatusCodeMessage() got = %v, want %v", idx, got, tt.want)
 			}
 			if got1 != tt.want1 {
-				t.Errorf("HTTPStatusCodeMessage() got1 = %v, want %v", got1, tt.want1)
+				t.Errorf("[%d] HTTPStatusCodeMessage() got1 = %v, want %v", idx, got1, tt.want1)
 			}
 			if got2 != tt.want2 {
-				t.Errorf("HTTPStatusCodeMessage() got2 = %v, want %v", got2, tt.want2)
+				t.Errorf("[%d] HTTPStatusCodeMessage() got2 = %v, want %v", idx, got2, tt.want2)
 			}
 		})
 	}

mirror.go

@@ -17,27 +17,20 @@ func As(err error, target interface{}) bool {
 	return errors.As(err, target)
 }
 
-// Join returns an error that combines all the given errors.
-// This is the exact implementation found in Go v1.20.
-// It will be removed when Go >= v1.20 becomes the LTS version, and would just call the
-// native Join after that.
 func Join(errs ...error) error {
-	n := 0
-	for _, err := range errs {
-		if err != nil {
-			n++
-		}
-	}
+	n := len(errs)
 	if n == 0 {
 		return nil
 	}
+
 	e := &joinError{
 		errs: make([]error, 0, n),
 	}
 	for _, err := range errs {
-		if err != nil {
-			e.errs = append(e.errs, err)
+		if err == nil {
+			continue
 		}
+		e.errs = append(e.errs, err)
 	}
 	return e
 }

mirror_test.go

@@ -3,6 +3,7 @@ package errors
 import (
 	"errors"
 	"fmt"
+	"net/http"
 	"strings"
 	"testing"
 )
@@ -123,9 +124,50 @@ func TestAs(t *testing.T) {
 	}
 
 	out := target.Error()
-	want := "/errors/mirror_test.go:120: type *Error"
+	want := "/errors/mirror_test.go:121: type *Error"
 	if !strings.Contains(out, want) {
 		t.Errorf("Error() = %s, want %s", out, want)
 	}
+}
+
+func TestJoin(t *testing.T) {
+	joined := Join(
+		errors.New("[1] std"),
+		New("[2] custom"),
+		errors.New("[3] std"),
+		Validation("[4] validation"),
+	)
+	got := fmt.Sprint(joined)
+	if !strings.Contains(got, "[1] std") ||
+		!strings.Contains(got, "mirror_test.go:136: [2] custom") ||
+		!strings.Contains(got, "[3] std") ||
+		!strings.Contains(got, "mirror_test.go:138: [4] validation") {
+		t.Error(got)
+	}
+
+	msg, ok := Message(joined)
+	if ok {
+		t.Errorf(
+			"Expected: false, got: %v",
+			ok,
+		)
+	}
+	expectedMsg := `[2] custom
+[4] validation`
+	if msg != expectedMsg {
+		t.Error(msg)
+	}
 
+	expectedCode := http.StatusUnprocessableEntity
+	code, msg, ok := HTTPStatusCodeMessage(joined)
+	if ok {
+		t.Errorf("expected false, got: %v", ok)
+	}
+	if expectedMsg != msg ||
+		expectedCode != code {
+		t.Errorf(
+			"Expected msg: %s, expected code: %d, got msg: %s, got code: %d",
+			expectedMsg, expectedCode, msg, code,
+		)
+	}
 }