Merge feature/1.13_errors

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 {
@@ -156,6 +156,25 @@ func (e *Error) Cause() error {
 	return e.cause
 }
 
+// Is returns true if and only if target is errorx error that passes errorx type check against current error.
+// This behaviour is exactly the same as that of IsOfType().
+// See also: errors.Is()
+func (e *Error) Is(target error) bool {
+	typedTarget := Cast(target)
+	return typedTarget != nil && IsOfType(e, typedTarget.Type())
+}
+
+// From errors package: if e.Unwrap() returns a non-nil error w, then we say that e wraps w.
+// Unwrap returns cause of current error in case it is wrapped transparently, nil otherwise.
+// See also: errors.Unwrap()
+func (e *Error) Unwrap() error {
+	if e.cause != nil && e.transparent {
+		return e.cause
+	} else {
+		return nil
+	}
+}
+
 // Format implements the Formatter interface.
 // Supported verbs:
 //
@@ -169,12 +188,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 +264,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_test.go

@@ -0,0 +1,105 @@
+// +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))
+		require.True(t, Cast(unwrapped).Type() == 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))
+		require.True(t, unwrapped == io.EOF)
+	})
+
+	t.Run("Nested", func(t *testing.T) {
+		err := Decorate(Decorate(testType.NewWithNoMessage(), ""), "")
+		unwrapped := errors.Unwrap(err)
+		require.NotNil(t, unwrapped)
+		unwrapped = errors.Unwrap(unwrapped)
+		require.NotNil(t, unwrapped)
+		require.True(t, IsOfType(unwrapped, testType))
+	})
+
+	t.Run("NestedWrapped", func(t *testing.T) {
+		err := Decorate(testTypeBar1.Wrap(testType.NewWithNoMessage(), ""), "")
+		unwrapped := errors.Unwrap(err)
+		require.NotNil(t, unwrapped)
+		require.True(t, IsOfType(unwrapped, testTypeBar1))
+		unwrapped = errors.Unwrap(unwrapped)
+		require.Nil(t, unwrapped)
+	})
+
+	t.Run("NestedForeign", func(t *testing.T) {
+		err := Decorate(Decorate(io.EOF, ""), "")
+		unwrapped := errors.Unwrap(err)
+		require.NotNil(t, unwrapped)
+		unwrapped = errors.Unwrap(unwrapped)
+		require.NotNil(t, unwrapped)
+		require.True(t, errors.Is(unwrapped, io.EOF))
+	})
+}
+
+func TestErrorIs(t *testing.T) {
+	t.Run("Trivial", func(t *testing.T) {
+		err := testType.NewWithNoMessage()
+		require.True(t, errors.Is(err, testType.NewWithNoMessage()))
+		require.False(t, errors.Is(err, testTypeBar1.NewWithNoMessage()))
+	})
+
+	t.Run("Wrap", func(t *testing.T) {
+		err := testTypeBar1.Wrap(testType.NewWithNoMessage(), "")
+		require.False(t, errors.Is(err, testType.NewWithNoMessage()))
+		require.True(t, errors.Is(err, testTypeBar1.NewWithNoMessage()))
+	})
+
+	t.Run("Supertype", func(t *testing.T) {
+		err := testSubtype0.Wrap(testTypeBar1.NewWithNoMessage(), "")
+		require.True(t, errors.Is(err, testType.NewWithNoMessage()))
+		require.True(t, errors.Is(err, testSubtype0.NewWithNoMessage()))
+		require.False(t, errors.Is(err, testTypeBar1.NewWithNoMessage()))
+	})
+
+	t.Run("Decorate", func(t *testing.T) {
+		err := Decorate(testType.NewWithNoMessage(), "")
+		require.True(t, errors.Is(err, testType.NewWithNoMessage()))
+	})
+
+	t.Run("DecorateForeign", func(t *testing.T) {
+		err := Decorate(io.EOF, "")
+		require.True(t, errors.Is(err, 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 errors.Unwrap() or 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...).