[patch] added helper function 'Type(err error)' of any error; returns errType(-1) if not of type *Error

[patch] added helper function 'HasType(err error, et errType)' to check if a provided errType is available anywhere in the wrapped errors

Author: bnkamalesh

README.md

@@ -15,6 +15,8 @@ Errors package is a drop-in replacement of the built-in Go errors package with n
 2. User friendly message
 3. File & line number prefixed to errors
 4. HTTP status code and user friendly message (wrapped messages are concatenated) for all error types
+5. Helper functions to generate each error type
+6. Helper function to get error Type, error type as int, check if error type is wrapped anywhere in chain
 
 In case of nested errors, the messages (in case of nesting with this package's error) & errors are also looped through the full chain of errors.
 
@@ -176,6 +178,7 @@ And output of the `fmt.Println(err.Error())`
 ```bash
 /Users/username/go/src/errorscheck/main.go:28 /Users/username/go/src/errorscheck/main.go:20 sinking bar
 ```
+
 ## Benchmark
 
 Benchmark run on:
@@ -189,13 +192,16 @@ $ go test -bench=.
 goos: darwin
 goarch: amd64
 pkg: github.com/bnkamalesh/errors
-Benchmark_Internal-8                                     1880440               635 ns/op
-Benchmark_InternalErr-8                                  1607589               746 ns/op
-Benchmark_InternalGetError-8                             1680831               711 ns/op
-Benchmark_InternalGetErrorWithNestedError-8              1462900               823 ns/op
-Benchmark_InternalGetMessage-8                           1859172               646 ns/op
-Benchmark_InternalGetMessageWithNestedError-8            1649259               726 ns/op
-Benchmark_HTTPStatusCodeMessage-8                       23497728                50.3 ns/op
+Benchmark_Internal-8                            	 1874256	       639 ns/op	     368 B/op	       5 allocs/op
+Benchmark_InternalErr-8                         	 1612707	       755 ns/op	     368 B/op	       5 allocs/op
+Benchmark_InternalGetError-8                    	 1700966	       706 ns/op	     464 B/op	       6 allocs/op
+Benchmark_InternalGetErrorWithNestedError-8     	 1458368	       823 ns/op	     464 B/op	       6 allocs/op
+Benchmark_InternalGetMessage-8                  	 1866562	       643 ns/op	     368 B/op	       5 allocs/op
+Benchmark_InternalGetMessageWithNestedError-8   	 1656597	       770 ns/op	     400 B/op	       6 allocs/op
+Benchmark_HTTPStatusCodeMessage-8               	26003678	        46.1 ns/op	      16 B/op	       1 allocs/op
+BenchmarkHasType-8                              	84689433	        14.2 ns/op	       0 B/op	       0 allocs/op
+PASS
+ok  	github.com/bnkamalesh/errors	14.478s
 ```
 
 ## Contributing

errors.go

@@ -82,7 +82,8 @@ func (e *Error) Error() string {
 	return e.fileLine + " " + DefaultMessage
 }
 
-// Message returns the user friendly message stored in the error struct
+// Message returns the user friendly message stored in the error struct. It will ignore all errors
+// which are not of type *Error
 func (e *Error) Message() string {
 	messages := make([]string, 0, 5)
 	messages = append(messages, e.message)

helper.go

@@ -1,6 +1,7 @@
 package errors
 
 import (
+	"errors"
 	"net/http"
 	"runtime"
 	"strconv"
@@ -179,3 +180,35 @@ func WriteHTTP(err error, w http.ResponseWriter) {
 	w.WriteHeader(status)
 	w.Write([]byte(msg))
 }
+
+// Type returns the errType if it's an instance of *Error, -1 otherwise
+func Type(err error) errType {
+	e, ok := err.(*Error)
+	if !ok {
+		return errType(-1)
+	}
+	return e.Type()
+}
+
+// Type returns the errType as integer if it's an instance of *Error, -1 otherwise
+func TypeInt(err error) int {
+	return Type(err).Int()
+}
+
+// HasType will check if the provided err type is available anywhere nested in the error
+func HasType(err error, et errType) bool {
+	if err == nil {
+		return false
+	}
+
+	e, _ := err.(*Error)
+	if e == nil {
+		return HasType(errors.Unwrap(err), et)
+	}
+
+	if e.Type() == et {
+		return true
+	}
+
+	return HasType(e.Unwrap(), et)
+}

helper_test.go

@@ -2,6 +2,7 @@ package errors
 
 import (
 	"errors"
+	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"reflect"
@@ -643,3 +644,132 @@ func TestWriteHTTP(t *testing.T) {
 		})
 	}
 }
+
+func TestHasCheck(t *testing.T) {
+	type args struct {
+		err error
+		et  errType
+	}
+	tests := []struct {
+		name string
+		args args
+		want bool
+	}{
+		{
+			name: "has required type, nested",
+			args: args{
+				err: ValidationErr(
+					DuplicateErr(
+						Internal("hello world"),
+						DefaultMessage,
+					),
+					DefaultMessage,
+				),
+				et: TypeInternal,
+			},
+			want: true,
+		},
+		{
+			name: "has required type, not nested",
+			args: args{
+				err: Internal("hello world"),
+				et:  TypeInternal,
+			},
+			want: true,
+		},
+		{
+			name: "does not have required type",
+			args: args{
+				err: ValidationErr(
+					DuplicateErr(
+						Internal("hello world"),
+						DefaultMessage,
+					),
+					DefaultMessage,
+				),
+				et: TypeInputBody,
+			},
+			want: false,
+		},
+		{
+			name: "*Error wrapped in external error",
+			args: args{
+				err: fmt.Errorf("unknown error %w", Internal("internal error")),
+				et:  TypeInternal,
+			},
+			want: true,
+		},
+		{
+			name: "other error type",
+			args: args{
+				err: fmt.Errorf("external error"),
+				et:  TypeInputBody,
+			},
+			want: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := HasType(tt.args.err, tt.args.et); got != tt.want {
+				t.Errorf("HasType() = %v, want %v %s", got, tt.want, tt.args.err.Error())
+			}
+		})
+	}
+}
+
+func BenchmarkHasType(b *testing.B) {
+	err := ValidationErr(
+		DuplicateErr(
+			SubscriptionExpiredErr(
+				ValidationErr(
+					InputBodyErr(
+						Internal("hello world"),
+						DefaultMessage,
+					),
+					DefaultMessage,
+				),
+				DefaultMessage,
+			),
+			DefaultMessage,
+		),
+		DefaultMessage,
+	)
+	for i := 0; i < b.N; i++ {
+		if !HasType(err, TypeInternal) {
+			b.Fatal("TypeInternal not found")
+		}
+	}
+}
+
+func TestTypeInt(t *testing.T) {
+	type args struct {
+		err error
+	}
+	tests := []struct {
+		name string
+		args args
+		want int
+	}{
+		{
+			name: "existing error type",
+			args: args{
+				err: Internal("internal error occurred"),
+			},
+			want: TypeInternal.Int(),
+		},
+		{
+			name: "non-existent error type",
+			args: args{
+				err: fmt.Errorf("unknown error type"),
+			},
+			want: -1,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := TypeInt(tt.args.err); got != tt.want {
+				t.Errorf("TypeInt() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}