feat: support std errors functions (#213)

* feat: support std errors functions

add function `Is`, `As` and `Unwrap`, like std errors, so that we can
continue to use pkg/errors with go1.13 compatibility

Signed-off-by: Sherlock Holo <[email protected]>

* style: delete useless comments

Signed-off-by: Sherlock Holo <[email protected]>

* build: update makefile

update makefile to download dependencies before test anything

Signed-off-by: Sherlock Holo <[email protected]>

* build: fix makefile

Signed-off-by: Sherlock Holo <[email protected]>

* chore: delete useless comments

Signed-off-by: Sherlock Holo <[email protected]>

* Restore Makefile

* revert: revert some change

some change are doing by PR #206 and #212 , so I don't need to do it

Signed-off-by: Sherlock Holo <[email protected]>

* test: add more check for As unit test

Signed-off-by: Sherlock Holo <[email protected]>

* revert: only support Is As Unwrap for >=go1.13

Signed-off-by: Sherlock Holo <[email protected]>

* feat(Unwrap): allow <go1.13 can use Unwrap

`Unwrap` just use type assert, it doesn't need go1.13 actually

Signed-off-by: Sherlock Holo <[email protected]>

* test: add go1.13 errors compatibility check

Signed-off-by: Sherlock Holo <[email protected]>

* refactor(Unwrap): don't allow <go1.13 use Unwrap

If we implement Unwrap ourselves, may create a risk of incompatibility
if Go 1.14 subtly changes its `Unwrap` implementation.
<go1.13 users doesn't have `Is` or `As`, if they want, they will use
xerrors and it also provides `Unwrap`

Signed-off-by: Sherlock Holo <[email protected]>

Author: Sherlock-Holo

go113.go

@@ -0,0 +1,38 @@
+// +build go1.13
+
+package errors
+
+import (
+	stderrors "errors"
+)
+
+// Is reports whether any error in err's chain matches target.
+//
+// The chain consists of err itself followed by the sequence of errors obtained by
+// repeatedly calling Unwrap.
+//
+// An error is considered to match a target if it is equal to that target or if
+// it implements a method Is(error) bool such that Is(target) returns true.
+func Is(err, target error) bool { return stderrors.Is(err, target) }
+
+// As finds the first error in err's chain that matches target, and if so, sets
+// target to that error value and returns true.
+//
+// The chain consists of err itself followed by the sequence of errors obtained by
+// repeatedly calling Unwrap.
+//
+// An error matches target if the error's concrete value is assignable to the value
+// pointed to by target, or if the error has a method As(interface{}) bool such that
+// As(target) returns true. In the latter case, the As method is responsible for
+// setting target.
+//
+// As will panic if target is not a non-nil pointer to either a type that implements
+// error, or to any interface type. As returns false if err is nil.
+func As(err error, target interface{}) bool { return stderrors.As(err, target) }
+
+// Unwrap returns the result of calling the Unwrap method on err, if err's
+// type contains an Unwrap method returning error.
+// Otherwise, Unwrap returns nil.
+func Unwrap(err error) error {
+	return stderrors.Unwrap(err)
+}

go113_test.go

@@ -3,14 +3,176 @@
 package errors
 
 import (
-	stdlib_errors "errors"
+	stderrors "errors"
+	"fmt"
+	"reflect"
 	"testing"
 )
 
 func TestErrorChainCompat(t *testing.T) {
-	err := stdlib_errors.New("error that gets wrapped")
+	err := stderrors.New("error that gets wrapped")
 	wrapped := Wrap(err, "wrapped up")
-	if !stdlib_errors.Is(wrapped, err) {
+	if !stderrors.Is(wrapped, err) {
 		t.Errorf("Wrap does not support Go 1.13 error chains")
 	}
 }
+
+func TestIs(t *testing.T) {
+	err := New("test")
+
+	type args struct {
+		err    error
+		target error
+	}
+	tests := []struct {
+		name string
+		args args
+		want bool
+	}{
+		{
+			name: "with stack",
+			args: args{
+				err:    WithStack(err),
+				target: err,
+			},
+			want: true,
+		},
+		{
+			name: "with message",
+			args: args{
+				err:    WithMessage(err, "test"),
+				target: err,
+			},
+			want: true,
+		},
+		{
+			name: "with message format",
+			args: args{
+				err:    WithMessagef(err, "%s", "test"),
+				target: err,
+			},
+			want: true,
+		},
+		{
+			name: "std errors compatibility",
+			args: args{
+				err:    fmt.Errorf("wrap it: %w", err),
+				target: err,
+			},
+			want: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := Is(tt.args.err, tt.args.target); got != tt.want {
+				t.Errorf("Is() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+type customErr struct {
+	msg string
+}
+
+func (c customErr) Error() string { return c.msg }
+
+func TestAs(t *testing.T) {
+	var err = customErr{msg: "test message"}
+
+	type args struct {
+		err    error
+		target interface{}
+	}
+	tests := []struct {
+		name string
+		args args
+		want bool
+	}{
+		{
+			name: "with stack",
+			args: args{
+				err:    WithStack(err),
+				target: new(customErr),
+			},
+			want: true,
+		},
+		{
+			name: "with message",
+			args: args{
+				err:    WithMessage(err, "test"),
+				target: new(customErr),
+			},
+			want: true,
+		},
+		{
+			name: "with message format",
+			args: args{
+				err:    WithMessagef(err, "%s", "test"),
+				target: new(customErr),
+			},
+			want: true,
+		},
+		{
+			name: "std errors compatibility",
+			args: args{
+				err:    fmt.Errorf("wrap it: %w", err),
+				target: new(customErr),
+			},
+			want: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := As(tt.args.err, tt.args.target); got != tt.want {
+				t.Errorf("As() = %v, want %v", got, tt.want)
+			}
+
+			ce := tt.args.target.(*customErr)
+			if !reflect.DeepEqual(err, *ce) {
+				t.Errorf("set target error failed, target error is %v", *ce)
+			}
+		})
+	}
+}
+
+func TestUnwrap(t *testing.T) {
+	err := New("test")
+
+	type args struct {
+		err error
+	}
+	tests := []struct {
+		name string
+		args args
+		want error
+	}{
+		{
+			name: "with stack",
+			args: args{err: WithStack(err)},
+			want: err,
+		},
+		{
+			name: "with message",
+			args: args{err: WithMessage(err, "test")},
+			want: err,
+		},
+		{
+			name: "with message format",
+			args: args{err: WithMessagef(err, "%s", "test")},
+			want: err,
+		},
+		{
+			name: "std errors compatibility",
+			args: args{err: fmt.Errorf("wrap: %w", err)},
+			want: err,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := Unwrap(tt.args.err); !reflect.DeepEqual(err, tt.want) {
+				t.Errorf("Unwrap() error = %v, want %v", err, tt.want)
+			}
+		})
+	}
+}