Merge pull request #2 from IQ-tech/feat/add_more_functions

feat/add more functions

Author: PoorlyDefinedBehaviour

.github/workflows/main.yml

@@ -0,0 +1,24 @@
+name: Main
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+jobs:
+  test:
+    strategy:
+      matrix:
+        go-version: [1.16, 1.17]
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Install Go
+        uses: actions/setup-go@v2
+        with:
+          go-version: ${{ matrix.go-version }}
+      - name: Checkout code
+        uses: actions/checkout@v2
+      - name: Test
+        run: go test ./...

README.md

@@ -7,28 +7,28 @@ This package holds helpers for better error handling, adding wrapped and context
 ### `ApplicationError`
 
 A generic application error, as a failure in parametrization or other unexpected error.  
-*This error usually translates to a HTTP **503 Service Unavailable** error.*
+_This error usually translates to a HTTP **503 Service Unavailable** error._
 
 ### `ConflictError`
 
 Indicates an action is conflicting with another action, as for example duplicated requests.  
-*This error usually translates to a HTTP **429 Conflict** error.*
+_This error usually translates to a HTTP **429 Conflict** error._
 
 ### `ForbiddenError`
 
 Indicates an action is not allowed, even if authenticated.  
-*This error usually translates to a HTTP **403 Forbidden** error.*
+_This error usually translates to a HTTP **403 Forbidden** error._
 
 ### `NotAuthorizedError`
 
 Indicates an action needs authorization or authentication to proceed.  
-*This error usually translated to a HTTP **401 Unauthorized** error.*
+_This error usually translated to a HTTP **401 Unauthorized** error._
 
 ### `ValidationError`
 
 Indicates that a parameter provided is not in the correct format or not present if required.  
 This error allows to set a property that is related to the error and also add sub validation errors to build a validation error chain.  
-*This error usually translates to a HTTP **422 Unprocessable Entity** error.*
+_This error usually translates to a HTTP **422 Unprocessable Entity** error._
 
 > **Note:** All error constructors return a wrapped version of the error, removing the need to always pair an error constructor with a call to `errors.Wrap`.
 
@@ -91,6 +91,26 @@ func Main() {
 }
 ```
 
+### `Wrapf(err error, format string, args ...interface{}) error`
+
+Same as `Wrap` but accepts a format string
+
+**Example:**
+
+```go
+response := service.MakeHttpRequest()
+if response.StatusCode != http.StatusOK {
+  return errors.Wrapf(`
+    unexpected http response status.
+    expected: %d
+    got: %d
+  `,
+    http.StatusOK,
+    response.StatusCode,
+  )
+}
+```
+
 ## `GetOriginalError(err error) error`
 
 There is a utility method to retrieve the original error from a chain of wrapped errors:
@@ -105,3 +125,47 @@ if originalErr == sql.ErrNoRows {
     // record not found
 }
 ```
+
+## `Is(a, b error) bool`
+
+Checks if two errors are the same
+
+**Example**
+
+```go
+err := f()
+if errors.Is(err, domain.SomeDomainError) {
+
+}
+```
+
+Errors will be unwrapped before comparison.
+
+Give preference to this function over
+
+```go
+errors.GetOriginalError(a) == errors.GetOriginalError(b)
+```
+
+## `Equals(a, b error) bool`
+
+Checks if two errors have the same error message
+
+**example**
+
+```go
+errA := ...
+errB := ...
+
+if errors.Equals(a, b) {
+
+}
+```
+
+Errors will be unwrapped before comparison.
+
+Give preference to this function over
+
+```go
+errors.GetOriginalError(a).Error() == errors.GetOriginalError(b).Error()
+```

errors.go

@@ -2,15 +2,25 @@
 package errors
 
 import (
+	stderrors "errors"
+	"fmt"
 	"runtime"
 	"strings"
 )
 
+func New(message string) error {
+	return stderrors.New(message)
+}
+
 // Wrap wraps an error with a context message and adds execution path
 func Wrap(err error, messages ...string) error {
 	return wrap(err, 4, messages...)
 }
 
+func Wrapf(err error, format string, args ...interface{}) error {
+	return wrap(err, 4, fmt.Sprintf(format, args...))
+}
+
 // Wrap wraps an error with a context message and adds execution path
 func wrap(err error, skipStack int, messages ...string) error {
 	if err != nil {
@@ -37,14 +47,39 @@ func GetOriginalError(err error) error {
 
 // getCallerFunction returns the name of a method in the method chain
 // indicated by the stackOrder index from last to first
-func getCallerFunction(stackOrder int) string {
+func getCallerFunction(skip int) string {
 	// get caller function path
-	pc := make([]uintptr, 1)
-	runtime.Callers(stackOrder, pc)
+	pc := make([]uintptr, 15)
+	n := runtime.Callers(skip, pc)
+	frames := runtime.CallersFrames(pc[:n])
+	frame, _ := frames.Next()
+	path := strings.Split(frame.Function, "/")
 
-	funcRef := runtime.FuncForPC(pc[0])
+	return path[len(path)-1]
+}
+
+// Returns true when two errors at the same.
+//
+// err := errors.New("oops")
+// errors.Is(err, err) => true
+//
+// err2 = errors.New("oops")
+// errors.Is(err, err2) => false
+func Is(a, b error) bool {
+	return GetOriginalError(a) == GetOriginalError((b))
+}
 
-	funcPath := strings.Split(funcRef.Name(), "/")
+// Returns true when two errors have the same error message.
+//
+// err := errors.New("oops")
+// errors.Equals(err, err) => true
+//
+// err2 := errors.New("oops...")
+// errors.Equals(err, err2) => false
+func Equals(a, b error) bool {
+	if a == nil || b == nil {
+		return Is(a, b)
+	}
 
-	return funcPath[len(funcPath)-1]
+	return GetOriginalError(a).Error() == GetOriginalError(b).Error()
 }

errors_test.go

@@ -4,6 +4,8 @@ package errors
 import (
 	"errors"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func wrap1() error {
@@ -15,12 +17,152 @@ func wrap2() error {
 }
 
 func TestWrap(t *testing.T) {
-	err := wrap2()
+	assert.Equal(t, "go-errors.TestWrap ➡︎ some error", Wrap(errors.New("some error")).Error())
+	assert.Equal(t, "go-errors.wrap1 ➡︎ some error", wrap1().Error())
+	assert.Equal(t, "go-errors.wrap2 ➡︎ go-errors.wrap1 ➡︎ some error", wrap2().Error())
+}
+
+func TestIs(t *testing.T) {
+	t.Parallel()
 
-	errMsg := err.Error()
-	expectedErrMsg := "go-errors.wrap2 ➡︎ go-errors.wrap1 ➡︎ some error"
+	errOne := errors.New("err 1")
+	errTwo := errors.New("err 2")
 
-	if errMsg != expectedErrMsg {
-		t.Errorf("Wrap() returned wrong error message: %s", errMsg)
+	tests := []struct {
+		lhs      error
+		rhs      error
+		expected bool
+	}{
+		{
+			lhs:      nil,
+			rhs:      NewValidationError("a", "b"),
+			expected: false,
+		},
+		{
+			lhs:      NewValidationError("a", "b"),
+			rhs:      nil,
+			expected: false,
+		},
+		{
+			lhs:      nil,
+			rhs:      Wrap(NewValidationError("a", "b")),
+			expected: false,
+		},
+		{
+			lhs:      Wrap(NewValidationError("a", "b")),
+			rhs:      nil,
+			expected: false,
+		},
+		{
+			lhs:      NewValidationError("a", "b"),
+			rhs:      NewValidationError("b", "c"),
+			expected: false,
+		},
+		{
+			lhs:      NewValidationError("a", "b"),
+			rhs:      NewValidationError("a", "b"),
+			expected: false,
+		},
+		{
+			lhs:      errOne,
+			rhs:      errTwo,
+			expected: false,
+		},
+		{
+			lhs:      errOne,
+			rhs:      errOne,
+			expected: true,
+		},
+		{
+			lhs:      Wrap(errOne),
+			rhs:      errOne,
+			expected: true,
+		},
+		{
+			lhs:      Wrap(errOne),
+			rhs:      Wrap(errOne),
+			expected: true,
+		},
+		{
+			lhs:      Wrap(Wrap(Wrap(errTwo))),
+			rhs:      Wrap(errTwo),
+			expected: true,
+		},
+		{
+			lhs:      Wrap(Wrap(Wrap(errOne))),
+			rhs:      Wrap(errTwo),
+			expected: false,
+		},
 	}
+
+	for _, tt := range tests {
+		actual := Is(tt.lhs, tt.rhs)
+
+		assert.Equal(t, tt.expected, actual)
+	}
+}
+
+func TestEquals(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		lhs      error
+		rhs      error
+		expected bool
+	}{
+		{
+			lhs:      nil,
+			rhs:      nil,
+			expected: true,
+		},
+		{
+			lhs:      nil,
+			rhs:      nil,
+			expected: true,
+		},
+		{
+			lhs:      NewValidationError("card_id", "Cartão deve ser informado!"),
+			rhs:      nil,
+			expected: false,
+		},
+		{
+			lhs:      nil,
+			rhs:      NewValidationError("card_id", "Cartão deve ser informado!"),
+			expected: false,
+		},
+		{
+			lhs:      NewValidationError("card_id", "Cartão deve ser informado!"),
+			rhs:      NewValidationError("card_id", "Cartão deve ser informado!"),
+			expected: true,
+		},
+		{
+			lhs:      NewValidationError("card_id", "Cartão deve ser informado!"),
+			rhs:      NewValidationError("card_id", "Cartão deve ser informado!"),
+			expected: true,
+		},
+	}
+
+	for _, tt := range tests {
+		actual := Equals(tt.lhs, tt.rhs)
+
+		assert.Equal(t, tt.expected, actual)
+	}
+}
+
+func TestWrapf(t *testing.T) {
+	t.Parallel()
+
+	t.Run("when error is nil", func(t *testing.T) {
+		t.Run("returns nil", func(t *testing.T) {
+			actual := Wrapf(nil, "%s", "test")
+			assert.Equal(t, nil, actual)
+		})
+	})
+
+	t.Run("when error is not nil", func(t *testing.T) {
+		t.Run("adds formatted string to wrapped error messages", func(t *testing.T) {
+			actual := Wrapf(New("oops"), "%s %d", "test", 1)
+			assert.Equal(t, "go-errors.TestWrapf.func2.1: test 1;  ➡︎ oops", actual.Error())
+		})
+	})
 }

go.mod

@@ -0,0 +1,5 @@
+module github.com/IQ-tech/go-errors
+
+go 1.16
+
+require github.com/stretchr/testify v1.7.0

go.sum

@@ -0,0 +1,11 @@
+github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=