-
Notifications
You must be signed in to change notification settings - Fork 0
/
errors_test.go
152 lines (121 loc) · 3.49 KB
/
errors_test.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
package friendly_test
import (
"log"
"testing"
"errors"
. "github.com/dylannz-sailthru/go-friendly"
pkgErrors "github.com/pkg/errors"
)
var (
ErrCause = errors.New("something secret went wrong")
ErrFriendly = errors.New("something public went wrong")
)
func someErr() error {
return ErrCause
}
func implementation() error {
err := someErr()
if err != nil {
return New().WithCause(err).WithFriendly(ErrFriendly)
}
return nil
}
func TestConstructor(t *testing.T) {
err := implementation()
e, ok := err.(Error)
if !ok {
log.Fatalf("expected err to be of type *Error, was: %T", err)
}
if e.Friendly() != ErrFriendly {
log.Fatalf("expected user error to be: %v, got: %v", ErrFriendly.Error(), e.Friendly())
}
if err.Error() != ErrCause.Error() {
log.Fatalf("expected cause to be: %v, got: %v", ErrCause.Error(), err.Error())
}
}
func TestUserCauseWithThirdPartyError(t *testing.T) {
c := New().WithCauseString("generic error")
err := New().WithCause(c).Err()
e, ok := err.(Error)
if !ok {
log.Fatalf("expected err to be of type *Error, was: %T", err)
}
if e.Friendly() != DefaultUserError {
log.Fatalf("expected user error to be: %v, got: %v", DefaultUserError, e.Friendly())
}
if err.Error() != c.Error() {
log.Fatalf("expected cause to be: %v, got: %v", c.Error(), err.Error())
}
}
func TestConstructorWithNilCauseAndNilFriendly(t *testing.T) {
err := New().WithCause(nil).WithFriendly(nil).Err()
if err != nil {
log.Fatalf("expected err to be nil, got: %v", err)
}
}
func TestConstructorWithNilCause(t *testing.T) {
err := New().WithCause(nil).WithFriendly(errors.New("some error")).Err()
if err != nil {
log.Fatalf("expected err to be nil, got: %v", err)
}
}
type unwrappableError struct {
msg string
cause error
}
func (e unwrappableError) Error() string {
return e.msg + ": " + e.cause.Error()
}
func (e unwrappableError) Unwrap() error {
return e.cause
}
func wrap(err error, str string) error {
return unwrappableError{
cause: err,
msg: str,
}
}
func TestUser(t *testing.T) {
err := New().WithCause(ErrCause).WithFriendly(ErrFriendly).Err()
wrapped := wrap(err, "some wrapper")
if ErrFriendly != Friendly(wrapped) {
log.Fatalf("expected unwrapped user error (%v) to equal original user err (%v)", Friendly(wrapped), ErrFriendly)
}
}
func TestUserWithNonUserError(t *testing.T) {
err := errors.New("some non-user error")
wrapped := wrap(err, "some wrapper")
if Friendly(wrapped) != nil {
log.Fatalf("expected unwrapped user error (%v) to be nil", Friendly(wrapped))
}
}
func TestPkgErrorsUser(t *testing.T) {
err := New().WithCause(ErrCause).WithFriendly(ErrFriendly).Err()
wrapped := pkgErrors.Wrap(err, "some wrapper")
if ErrFriendly != Friendly(wrapped) {
log.Fatalf("expected unwrapped user error (%v) to equal original user err (%v)", Friendly(wrapped), ErrFriendly)
}
}
type hashicorpErrwrappable struct {
msg string
cause error
}
func (e hashicorpErrwrappable) Error() string {
return e.msg + ": " + e.cause.Error()
}
func (e hashicorpErrwrappable) WrappedErrors() []error {
return []error{e.cause}
}
func hashicorpErrwrap(err error, str string) error {
return hashicorpErrwrappable{
cause: err,
msg: str,
}
}
func TestHashicorpErrwrap(t *testing.T) {
err := New().WithCause(ErrCause).WithFriendly(ErrFriendly).Err()
wrapped := hashicorpErrwrap(err, "some wrapper")
if ErrFriendly != Friendly(wrapped) {
log.Fatalf("expected unwrapped user error (%v) to equal original user err (%v)", Friendly(wrapped), ErrFriendly)
}
}