add basic Unwrap impl and tests

Author: PeterIvanov

error.go

@@ -103,7 +103,7 @@ func (e *Error) HasTrait(key Trait) bool {
 	return false
 }
 
-// IsOfType is a proper type check for an error.
+// IsOfType is a proper type check for an errorx-based errors.
 // It takes the transparency and error types hierarchy into account,
 // so that type check against any supertype of the original cause passes.
 func (e *Error) IsOfType(t *Type) bool {
@@ -169,12 +169,12 @@ func (e *Error) Format(s fmt.State, verb rune) {
 	message := e.fullMessage()
 	switch verb {
 	case 'v':
-		io.WriteString(s, message)
+		_, _ = io.WriteString(s, message)
 		if s.Flag('+') {
 			e.stackTrace.Format(s, verb)
 		}
 	case 's':
-		io.WriteString(s, message)
+		_, _ = io.WriteString(s, message)
 	}
 }
 
@@ -245,29 +245,3 @@ func (e *Error) messageText() string {
 	}
 	return message
 }
-
-func joinStringsIfNonEmpty(delimiter string, parts ...string) string {
-	switch len(parts) {
-	case 0:
-		return ""
-	case 1:
-		return parts[0]
-	case 2:
-		if len(parts[0]) == 0 {
-			return parts[1]
-		} else if len(parts[1]) == 0 {
-			return parts[0]
-		} else {
-			return parts[0] + delimiter + parts[1]
-		}
-	default:
-		filteredParts := make([]string, 0, len(parts))
-		for _, part := range parts {
-			if len(part) > 0 {
-				filteredParts = append(filteredParts, part)
-			}
-		}
-
-		return strings.Join(filteredParts, delimiter)
-	}
-}

error_113.go

@@ -0,0 +1,38 @@
+// +build go1.13
+
+package errorx
+
+// todo godoc
+func (e *Error) As(target interface{}) bool {
+	targetError, ok := target.(*error)
+	if !ok {
+		return false
+	}
+
+	if !e.Is(*targetError) {
+		return false
+	}
+
+	// todo inject
+	return true
+}
+
+// todo godoc
+func (e *Error) Is(target error) bool {
+	typedTarget := Cast(target)
+	if typedTarget == nil {
+		return false
+	}
+
+	return e.IsOfType(typedTarget.Type()) // todo test with parents
+}
+
+// todo godoc
+// If e.Unwrap() returns a non-nil error w, then we say that e wraps w.
+func (e *Error) Unwrap() error {
+	if e.cause != nil && e.transparent {
+		return e.cause
+	} else {
+		return nil
+	}
+}

error_113_test.go

@@ -0,0 +1,45 @@
+// +build go1.13
+
+package errorx
+
+import (
+	"errors"
+	"io"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestErrorUnwrap(t *testing.T) {
+	t.Run("Trivial", func(t *testing.T) {
+		err := testType.NewWithNoMessage()
+		unwrapped := errors.Unwrap(err)
+		require.Nil(t, unwrapped)
+	})
+
+	t.Run("Wrap", func(t *testing.T) {
+		err := testTypeBar1.Wrap(testType.NewWithNoMessage(), "")
+		unwrapped := errors.Unwrap(err)
+		require.Nil(t, unwrapped)
+	})
+
+	t.Run("WrapForeign", func(t *testing.T) {
+		err := testTypeBar1.Wrap(io.EOF, "")
+		unwrapped := errors.Unwrap(err)
+		require.Nil(t, unwrapped)
+	})
+
+	t.Run("Decorate", func(t *testing.T) {
+		err := Decorate(testType.NewWithNoMessage(), "")
+		unwrapped := errors.Unwrap(err)
+		require.NotNil(t, unwrapped)
+		require.True(t, IsOfType(unwrapped, testType))
+	})
+
+	t.Run("DecorateForeign", func(t *testing.T) {
+		err := Decorate(io.EOF, "")
+		unwrapped := errors.Unwrap(err)
+		require.NotNil(t, unwrapped)
+		require.True(t, errors.Is(unwrapped, io.EOF))
+	})
+}

helper.go

@@ -0,0 +1,30 @@
+package errorx
+
+import "strings"
+
+func joinStringsIfNonEmpty(delimiter string, parts ...string) string {
+	switch len(parts) {
+	case 0:
+		return ""
+	case 1:
+		return parts[0]
+	case 2:
+		if len(parts[0]) == 0 {
+			return parts[1]
+		} else if len(parts[1]) == 0 {
+			return parts[0]
+		} else {
+			return parts[0] + delimiter + parts[1]
+		}
+	default:
+		filteredParts := make([]string, 0, len(parts))
+		for _, part := range parts {
+			if len(part) > 0 {
+				filteredParts = append(filteredParts, part)
+			}
+		}
+
+		return strings.Join(filteredParts, delimiter)
+	}
+}
+

type.go

@@ -56,6 +56,7 @@ func (t *Type) NewWithNoMessage() *Error {
 // The original error will not pass its dynamic properties, and those are accessible only via direct walk over Cause() chain.
 // Without args, leaves the original message intact, so a message may be generated or provided externally.
 // With args, a formatting is performed, and it is therefore expected a format string to be constant.
+// NB: Wrap is NOT the reverse of Error.Unwrap method; name may be changed in future releases to avoid confusion.
 func (t *Type) Wrap(err error, message string, args ...interface{}) *Error {
 	return NewErrorBuilder(t).
 		WithConditionallyFormattedMessage(message, args...).