Skip to content

Commit 9851d30

Browse files
creastycreasty
authored
Merge pull request #16 from srvc/creasty/full_message
Unify Error and FullMessage and deprecate the latter
2 parents 27a3158 + 6b822fd commit 9851d30

6 files changed

+60
-56
lines changed

‎.travis.yml

+1-1
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@ cache:
1515
- vendor
1616

1717
before_install:
18-
- go get -u github.com/golang/lint/golint
18+
- go get -u golang.org/x/lint/golint
1919

2020
install:
2121
- go get -t -u ./...

‎README.md

+1-1
Original file line numberDiff line numberDiff line change
@@ -50,7 +50,7 @@ as a value that satisfies error.
5050
It also records the stack trace at the point it was called.
5151

5252
```go
53-
func Wrap(err error, opts ...Annotator) error {
53+
func Wrap(err error, annotators ...Annotator) error
5454
```
5555

5656
Wrap returns an error annotated with a stack trace from the point it was called,

‎error.go

+7-7
Original file line numberDiff line numberDiff line change
@@ -46,12 +46,11 @@ func Errorf(format string, args ...interface{}) error {
4646
return err
4747
}
4848

49-
// Error implements error interface
49+
// Error implements error interface.
50+
// It returns a string of messages and the root error concatenated with ": ".
5051
func (e *Error) Error() string {
51-
if message := e.FullMessage(); message != "" {
52-
return message
53-
}
54-
return e.Err.Error()
52+
messages := append(e.Messages, e.Err.Error())
53+
return strings.Join(messages, messageDelimiter)
5554
}
5655

5756
// Copy creates a copy of the current object
@@ -75,9 +74,10 @@ func (e *Error) LastMessage() string {
7574
return e.Messages[0]
7675
}
7776

78-
// FullMessage returns a string of messages concatenated with ": "
77+
// FullMessage is marked as deprecated in favor of `Error`.
78+
// This method will be removed in the next major release.
7979
func (e *Error) FullMessage() string {
80-
return strings.Join(e.Messages, messageDelimiter)
80+
return e.Error()
8181
}
8282

8383
// Wrap returns an error annotated with a stack trace from the point it was called,

‎error_test.go

+42-44
Original file line numberDiff line numberDiff line change
@@ -9,23 +9,21 @@ import (
99
)
1010

1111
func TestNew(t *testing.T) {
12-
err := New("message")
13-
assert.Equal(t, "message", err.Error())
12+
err := New("err")
13+
assert.Equal(t, "err", err.Error())
1414

1515
appErr := Unwrap(err)
16-
assert.Equal(t, err.Error(), appErr.Err.Error())
17-
assert.Equal(t, "", appErr.FullMessage())
16+
assert.Equal(t, "err", appErr.Error())
1817
assert.NotEmpty(t, appErr.StackTrace)
1918
assert.Equal(t, "TestNew", appErr.StackTrace[0].Func)
2019
}
2120

2221
func TestErrorf(t *testing.T) {
23-
err := Errorf("message %d", 123)
24-
assert.Equal(t, "message 123", err.Error())
22+
err := Errorf("err %d", 123)
23+
assert.Equal(t, "err 123", err.Error())
2524

2625
appErr := Unwrap(err)
27-
assert.Equal(t, err.Error(), appErr.Err.Error())
28-
assert.Equal(t, "", appErr.FullMessage())
26+
assert.Equal(t, "err 123", appErr.Error())
2927
assert.NotEmpty(t, appErr.StackTrace)
3028
assert.Equal(t, "TestErrorf", appErr.StackTrace[0].Func)
3129
}
@@ -43,7 +41,7 @@ func TestError_FullMessage(t *testing.T) {
4341
Err: errors.New("err"),
4442
Messages: []string{"message 2", "message 1"},
4543
}
46-
assert.Equal(t, "message 2: message 1", err.FullMessage())
44+
assert.Equal(t, err.Error(), err.FullMessage())
4745
}
4846

4947
func TestWithMessage(t *testing.T) {
@@ -53,38 +51,38 @@ func TestWithMessage(t *testing.T) {
5351
})
5452

5553
t.Run("bare", func(t *testing.T) {
56-
err0 := errors.New("original")
54+
err0 := errors.New("origin")
5755

5856
err1 := Wrap(err0, WithMessage("message"))
59-
assert.Equal(t, "message", err1.Error())
57+
assert.Equal(t, "message: origin", err1.Error())
6058

6159
appErr := Unwrap(err1)
6260
assert.Equal(t, err0, appErr.Err)
63-
assert.Equal(t, err1.Error(), appErr.FullMessage())
61+
assert.Equal(t, err1.Error(), appErr.Error())
6462
})
6563

6664
t.Run("already wrapped", func(t *testing.T) {
67-
err0 := errors.New("original")
65+
err0 := errors.New("origin")
6866

6967
err1 := &Error{
7068
Err: err0,
7169
Messages: []string{"message 1"},
7270
Code: 400,
7371
}
7472
err2 := Wrap(err1, WithMessage("message 2"))
75-
assert.Equal(t, "message 2: message 1", err2.Error())
73+
assert.Equal(t, "message 2: message 1: origin", err2.Error())
7674

7775
{
7876
appErr := Unwrap(err1)
7977
assert.Equal(t, err0, appErr.Err)
80-
assert.Equal(t, err1.Error(), appErr.FullMessage())
78+
assert.Equal(t, err1.Error(), appErr.Error())
8179
assert.Equal(t, 400, appErr.Code)
8280
}
8381

8482
{
8583
appErr := Unwrap(err2)
8684
assert.Equal(t, err0, appErr.Err)
87-
assert.Equal(t, err2.Error(), appErr.FullMessage())
85+
assert.Equal(t, err2.Error(), appErr.Error())
8886
assert.Equal(t, 400, appErr.Code)
8987
}
9088
})
@@ -97,17 +95,17 @@ func TestWithCode(t *testing.T) {
9795
})
9896

9997
t.Run("bare", func(t *testing.T) {
100-
err0 := errors.New("original")
98+
err0 := errors.New("origin")
10199

102100
err1 := Wrap(err0, WithCode(200))
103101

104102
appErr := Unwrap(err1)
105103
assert.Equal(t, err0, appErr.Err)
106-
assert.Equal(t, "", appErr.FullMessage())
104+
assert.Equal(t, "origin", appErr.Error())
107105
})
108106

109107
t.Run("already wrapped", func(t *testing.T) {
110-
err0 := errors.New("original")
108+
err0 := errors.New("origin")
111109

112110
err1 := &Error{
113111
Err: err0,
@@ -119,14 +117,14 @@ func TestWithCode(t *testing.T) {
119117
{
120118
appErr := Unwrap(err1)
121119
assert.Equal(t, err0, appErr.Err)
122-
assert.Equal(t, err1.Error(), appErr.FullMessage())
120+
assert.Equal(t, "message 1: origin", appErr.Error())
123121
assert.Equal(t, 400, appErr.Code)
124122
}
125123

126124
{
127125
appErr := Unwrap(err2)
128126
assert.Equal(t, err0, appErr.Err)
129-
assert.Equal(t, err1.Error(), appErr.FullMessage())
127+
assert.Equal(t, "message 1: origin", appErr.Error())
130128
assert.Equal(t, 500, appErr.Code)
131129
}
132130
})
@@ -139,7 +137,7 @@ func TestWithTags(t *testing.T) {
139137
})
140138

141139
t.Run("bare", func(t *testing.T) {
142-
err0 := errors.New("original")
140+
err0 := errors.New("origin")
143141

144142
err1 := Wrap(err0, WithTags("http", "notice_only"))
145143

@@ -149,7 +147,7 @@ func TestWithTags(t *testing.T) {
149147
})
150148

151149
t.Run("already wrapped", func(t *testing.T) {
152-
err0 := errors.New("original")
150+
err0 := errors.New("origin")
153151

154152
err1 := Wrap(err0, WithTags("http", "notice_only"))
155153
err2 := Wrap(err1, WithTags("security"))
@@ -175,7 +173,7 @@ func TestWithParams(t *testing.T) {
175173
})
176174

177175
t.Run("bare", func(t *testing.T) {
178-
err0 := errors.New("original")
176+
err0 := errors.New("origin")
179177

180178
err1 := Wrap(err0, WithParams(H{"foo": 1, "bar": "baz"}))
181179

@@ -185,7 +183,7 @@ func TestWithParams(t *testing.T) {
185183
})
186184

187185
t.Run("short", func(t *testing.T) {
188-
err0 := errors.New("original")
186+
err0 := errors.New("origin")
189187

190188
err1 := Wrap(err0, WithParam("foo", 1))
191189

@@ -195,7 +193,7 @@ func TestWithParams(t *testing.T) {
195193
})
196194

197195
t.Run("already wrapped", func(t *testing.T) {
198-
err0 := errors.New("original")
196+
err0 := errors.New("origin")
199197

200198
err1 := Wrap(err0, WithParams(H{"foo": 1, "bar": "baz"}))
201199
err2 := Wrap(err1, WithParams(H{"qux": true, "foo": "quux"}))
@@ -221,17 +219,17 @@ func TestWithIgnorable(t *testing.T) {
221219
})
222220

223221
t.Run("bare", func(t *testing.T) {
224-
err0 := errors.New("original")
222+
err0 := errors.New("origin")
225223

226224
err1 := Wrap(err0, WithIgnorable())
227225

228226
appErr := Unwrap(err1)
229227
assert.Equal(t, err0, appErr.Err)
230-
assert.Equal(t, "", appErr.FullMessage())
228+
assert.Equal(t, "origin", appErr.Error())
231229
})
232230

233231
t.Run("already wrapped", func(t *testing.T) {
234-
err0 := errors.New("original")
232+
err0 := errors.New("origin")
235233

236234
err1 := Wrap(err0, WithIgnorable())
237235
err2 := Wrap(err1, WithIgnorable())
@@ -264,56 +262,56 @@ func TestWrap(t *testing.T) {
264262
})
265263

266264
t.Run("bare", func(t *testing.T) {
267-
err0 := errors.New("original")
265+
err0 := errors.New("origin")
268266

269267
err1 := wrapOrigin(err0)
270-
assert.Equal(t, "original", err1.Error())
268+
assert.Equal(t, "origin", err1.Error())
271269

272270
appErr := Unwrap(err1)
273271
assert.Equal(t, err0, appErr.Err)
274-
assert.Equal(t, "", appErr.FullMessage())
272+
assert.Equal(t, "origin", appErr.Error())
275273
assert.NotEmpty(t, appErr.StackTrace)
276274
assert.Equal(t, "wrapOrigin", appErr.StackTrace[0].Func)
277275
})
278276

279277
t.Run("already wrapped", func(t *testing.T) {
280-
err0 := errors.New("original")
278+
err0 := errors.New("origin")
281279

282280
err1 := wrapOrigin(err0)
283281
err2 := wrapOrigin(err1)
284-
assert.Equal(t, "original", err2.Error())
282+
assert.Equal(t, "origin", err2.Error())
285283

286284
appErr := Unwrap(err2)
287285
assert.Equal(t, err0, appErr.Err)
288-
assert.Equal(t, "", appErr.FullMessage())
286+
assert.Equal(t, "origin", appErr.Error())
289287
assert.NotEmpty(t, appErr.StackTrace)
290288
assert.Equal(t, "wrapOrigin", appErr.StackTrace[0].Func)
291289
})
292290

293291
t.Run("with pkg/errors", func(t *testing.T) {
294292
t.Run("pkg/errors.New", func(t *testing.T) {
295-
err0 := pkgErrorsNew("original")
293+
err0 := pkgErrorsNew("origin")
296294

297295
err1 := wrapOrigin(err0)
298-
assert.Equal(t, "original", err1.Error())
296+
assert.Equal(t, "origin", err1.Error())
299297

300298
appErr := Unwrap(err1)
301299
assert.Equal(t, err0, appErr.Err)
302-
assert.Equal(t, "", appErr.FullMessage())
300+
assert.Equal(t, "origin", appErr.Error())
303301
assert.NotEmpty(t, appErr.StackTrace)
304302
assert.Equal(t, "pkgErrorsNew", appErr.StackTrace[0].Func)
305303
})
306304

307305
t.Run("pkg/errors.Wrap", func(t *testing.T) {
308-
err0 := errors.New("original")
306+
err0 := errors.New("origin")
309307
err1 := pkgErrorsWrap(err0, "message")
310308

311309
err2 := wrapOrigin(err1)
312-
assert.Equal(t, "message: original", err2.Error())
310+
assert.Equal(t, "message: origin", err2.Error())
313311

314312
appErr := Unwrap(err2)
315313
assert.Equal(t, err0, appErr.Err)
316-
assert.Equal(t, "message: original", appErr.FullMessage())
314+
assert.Equal(t, "message: origin", appErr.Error())
317315
assert.NotEmpty(t, appErr.StackTrace)
318316
assert.Equal(t, "pkgErrorsWrap", appErr.StackTrace[0].Func)
319317
})
@@ -323,7 +321,7 @@ func TestWrap(t *testing.T) {
323321
func TestAll(t *testing.T) {
324322
{
325323
appErr := Unwrap(errFunc3())
326-
assert.Equal(t, "e2: e1: e0", appErr.FullMessage())
324+
assert.Equal(t, "e2: e1: e0", appErr.Error())
327325
assert.Equal(t, nil, appErr.Code)
328326
assert.Equal(t, false, appErr.Ignorable)
329327
assert.Equal(t, []string{
@@ -337,7 +335,7 @@ func TestAll(t *testing.T) {
337335

338336
{
339337
appErr := Unwrap(errFunc4())
340-
assert.Equal(t, "e4: e2: e1: e0", appErr.FullMessage())
338+
assert.Equal(t, "e4: e2: e1: e0", appErr.Error())
341339
assert.Equal(t, 500, appErr.Code)
342340
assert.Equal(t, true, appErr.Ignorable)
343341
assert.Equal(t, []string{
@@ -352,7 +350,7 @@ func TestAll(t *testing.T) {
352350

353351
{
354352
appErr := Unwrap(errFunc4Goroutine())
355-
assert.Equal(t, "e4: e2: e1: e0", appErr.FullMessage())
353+
assert.Equal(t, "e4: e2: e1: e0", appErr.Error())
356354
assert.Equal(t, 500, appErr.Code)
357355
assert.Equal(t, true, appErr.Ignorable)
358356
assert.Equal(t, []string{

‎pkgerrors.go

+8-2
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,8 @@
11
package fail
22

33
import (
4+
"strings"
5+
46
pkgerrors "github.com/pkg/errors"
57
)
68

@@ -10,6 +12,10 @@ type pkgError struct {
1012
StackTrace StackTrace
1113
}
1214

15+
const (
16+
pkgErrorsMessageDelimiter = ": "
17+
)
18+
1319
// extractPkgError extracts the innermost error from the given error.
1420
// It converts the stack trace that is annotated by pkg/errors into fail.StackTrace.
1521
// If the error doesn't have a stack trace or a causer of pkg/errors,
@@ -39,8 +45,8 @@ func extractPkgError(err error) pkgError {
3945
}
4046

4147
var msg string
42-
if err.Error() != rootErr.Error() {
43-
msg = err.Error()
48+
if strings.HasSuffix(err.Error(), pkgErrorsMessageDelimiter+rootErr.Error()) {
49+
msg = strings.TrimSuffix(err.Error(), pkgErrorsMessageDelimiter+rootErr.Error())
4450
}
4551

4652
return pkgError{

‎pkgerrors_test.go

+1-1
Original file line numberDiff line numberDiff line change
@@ -27,7 +27,7 @@ func TestExtractPkgError(t *testing.T) {
2727

2828
pkgErr := extractPkgError(err1)
2929
assert.NotNil(t, pkgErr)
30-
assert.Equal(t, "message: error", pkgErr.Message)
30+
assert.Equal(t, "message", pkgErr.Message)
3131
assert.Equal(t, err0, pkgErr.Err)
3232
assert.NotEmpty(t, pkgErr.StackTrace)
3333
assert.Equal(t, "pkgErrorsWrap", pkgErr.StackTrace[0].Func)

0 commit comments

Comments
 (0)