Merge pull request #83 from Scalingo/fix/gohandlers/15

Better handling of ValidationErrors

Author: Soulou

errors/cause.go

@@ -0,0 +1,31 @@
+package errors
+
+import (
+	"reflect"
+
+	"github.com/pkg/errors"
+)
+
+// IsRootCause return true if the cause of the given error is the same type as
+// mytype.
+// This function takes the cause of an error if the errors stack has been
+// wrapped with errors.Wrapf or errgo.Notef or errgo.NoteMask or errgo.Mask.
+//
+// Example:
+//    errors.IsRootCause(err, &ValidationErrors{})
+func IsRootCause(err error, mytype interface{}) bool {
+	t := reflect.TypeOf(mytype)
+	errCause := errors.Cause(err)
+	errRoot := ErrgoRoot(err)
+	return reflect.TypeOf(errCause) == t || reflect.TypeOf(errRoot) == t
+}
+
+// RootCause returns the cause of an errors stack, whatever the method they used
+// to be stacked: either errgo.Notef or errors.Wrapf.
+func RootCause(err error) error {
+	errCause := errors.Cause(err)
+	if errCause == nil {
+		errCause = ErrgoRoot(err)
+	}
+	return errCause
+}

errors/cause_test.go

@@ -0,0 +1,67 @@
+package errors
+
+import (
+	"testing"
+
+	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
+	errgo "gopkg.in/errgo.v1"
+)
+
+func Test_IsRootCause(t *testing.T) {
+	t.Run("given an error stack with errgo.Notef", func(t *testing.T) {
+		var err error
+		err = (&ValidationErrors{})
+		err = errgo.Notef(err, "biniou")
+
+		assert.True(t, IsRootCause(err, &ValidationErrors{}))
+		assert.False(t, IsRootCause(err, ValidationErrors{}))
+	})
+
+	t.Run("given an error stack with errors.Wrapf", func(t *testing.T) {
+		var err error
+		err = (&ValidationErrors{})
+		err = errors.Wrapf(err, "biniou")
+
+		assert.True(t, IsRootCause(err, &ValidationErrors{}))
+		assert.False(t, IsRootCause(err, ValidationErrors{}))
+	})
+}
+
+func Test_RootCause(t *testing.T) {
+	t.Run("given an error stack with errgo.Mask", func(t *testing.T) {
+		var err error
+		err = (&ValidationErrors{
+			Errors: map[string][]string{
+				"test": []string{"biniou"},
+			},
+		})
+		err = errgo.Mask(err, errgo.Any)
+
+		assert.Equal(t, "test=biniou", RootCause(err).Error())
+	})
+
+	t.Run("given an error stack with errgo.Notef", func(t *testing.T) {
+		var err error
+		err = (&ValidationErrors{
+			Errors: map[string][]string{
+				"test": []string{"biniou"},
+			},
+		})
+		err = errgo.Notef(err, "pouet")
+
+		assert.Equal(t, "test=biniou", RootCause(err).Error())
+	})
+
+	t.Run("given an error stack with errors.Wrap", func(t *testing.T) {
+		var err error
+		err = (&ValidationErrors{
+			Errors: map[string][]string{
+				"test": []string{"biniou"},
+			},
+		})
+		err = errors.Wrap(err, "pouet")
+
+		assert.Equal(t, "test=biniou", RootCause(err).Error())
+	})
+}

errors/validation_errors.go

@@ -0,0 +1,68 @@
+package errors
+
+import (
+	"bytes"
+	"strings"
+)
+
+// ValidationErrors store each errors associated to every fields of a model
+type ValidationErrors struct {
+	Errors map[string][]string `json:"errors"`
+}
+
+func (v *ValidationErrors) Error() string {
+	var buffer bytes.Buffer
+
+	for field, errors := range v.Errors {
+		buffer.WriteString(field)
+		buffer.WriteString("=")
+		buffer.WriteString(strings.Join(errors, ","))
+	}
+	return buffer.String()
+}
+
+// ValidationErrorsBuilder is used to provide a simple way to create a ValidationErrors struct. The typical usecase is:
+//	func (m *MyModel) Validate(ctx context.Context) *ValidationErrors {
+//		validations := document.NewValidationErrorsBuilder()
+//
+//		if m.Name == "" {
+//			validations.Set("name", "should not be empty")
+//		}
+//
+//		if m.Email == "" {
+//			validations.Set("email", "should not be empty")
+//		}
+//
+//		return validations.Build()
+//	}
+type ValidationErrorsBuilder struct {
+	errors map[string][]string
+}
+
+// NewValidationErrors return an empty ValidationErrors struct
+func NewValidationErrorsBuilder() *ValidationErrorsBuilder {
+	return &ValidationErrorsBuilder{
+		errors: make(map[string][]string),
+	}
+}
+
+// Set will add an error on a specific field, if the field already contains an error, it will just add it to the current errors list
+func (v *ValidationErrorsBuilder) Set(field, err string) {
+	v.errors[field] = append(v.errors[field], err)
+}
+
+// Get will return all errors set for a specific field
+func (v *ValidationErrorsBuilder) Get(field string) []string {
+	return v.errors[field]
+}
+
+// Build will send a ValidationErrors struct if there is some errors or nil if no errors has been defined
+func (v *ValidationErrorsBuilder) Build() *ValidationErrors {
+	if len(v.errors) == 0 {
+		return nil
+	}
+
+	return &ValidationErrors{
+		Errors: v.errors,
+	}
+}

mongo/document/validation_error.go

@@ -1,68 +1,18 @@
 package document
 
 import (
-	"bytes"
-	"strings"
+	"github.com/Scalingo/go-utils/errors"
 )
 
-// ValidationErrors store each errors associated to every fields of a model
-type ValidationErrors struct {
-	Errors map[string][]string `json:"errors"`
-}
-
-func (v *ValidationErrors) Error() string {
-	var buffer bytes.Buffer
-
-	for field, errors := range v.Errors {
-		buffer.WriteString(field)
-		buffer.WriteString("=")
-		buffer.WriteString(strings.Join(errors, ","))
-	}
-	return buffer.String()
-}
+// ValidationErrors is a type alias of errors.ValidationErrors. It is defined to
+// keep retro-compatibility
+type ValidationErrors = errors.ValidationErrors
 
-// ValidationErrorsBuilder is used to provide a simple way to create a ValidationErrors struct. The typical usecase is:
-//	func (m *MyModel) Validate(ctx context.Context) *ValidationErrors {
-//		validations := document.NewValidationErrorsBuilder()
-//
-//		if m.Name == "" {
-//			validations.Set("name", "should not be empty")
-//		}
-//
-//		if m.Email == "" {
-//			validations.Set("email", "should not be empty")
-//		}
-//
-//		return validations.Build()
-//	}
-type ValidationErrorsBuilder struct {
-	errors map[string][]string
-}
+// ValidationErrorsBuilder is a type alias of errors.ValidationErrorsBuilder.
+// It is defined to keep retro-compatibility
+type ValidationErrorsBuilder = errors.ValidationErrorsBuilder
 
 // NewValidationErrors return an empty ValidationErrors struct
 func NewValidationErrorsBuilder() *ValidationErrorsBuilder {
-	return &ValidationErrorsBuilder{
-		errors: make(map[string][]string),
-	}
-}
-
-// Set will add an error on a specific field, if the field already contains an error, it will just add it to the current errors list
-func (v *ValidationErrorsBuilder) Set(field, err string) {
-	v.errors[field] = append(v.errors[field], err)
-}
-
-// Get will return all errors set for a specific field
-func (v *ValidationErrorsBuilder) Get(field string) []string {
-	return v.errors[field]
-}
-
-// Build will send a ValidationErrors struct if there is some errors or nil if no errors has been defined
-func (v *ValidationErrorsBuilder) Build() *ValidationErrors {
-	if len(v.errors) == 0 {
-		return nil
-	}
-
-	return &ValidationErrors{
-		Errors: v.errors,
-	}
+	return errors.NewValidationErrorsBuilder()
 }