104 lines
2.9 KiB
Go
104 lines
2.9 KiB
Go
package errx
|
|
|
|
import (
|
|
"errors"
|
|
"io"
|
|
"testing"
|
|
)
|
|
|
|
func TestError_Format(t *testing.T) {
|
|
plain := errors.New("connection refused")
|
|
nested := &Error{Op: "db.Query", Err: plain}
|
|
|
|
tests := []struct {
|
|
name string
|
|
err *Error
|
|
want string
|
|
}{
|
|
{"op only", &Error{Op: "users.Get"}, "users.Get"},
|
|
{"op+msg", &Error{Op: "users.Get", Msg: "lookup failed"}, "users.Get: lookup failed"},
|
|
{"op+err", &Error{Op: "users.Get", Err: plain}, "users.Get: connection refused"},
|
|
{"op+msg+err", &Error{Op: "users.Get", Msg: "lookup failed", Err: plain}, "users.Get: lookup failed: connection refused"},
|
|
{"nested *Error", &Error{Op: "users.Get", Msg: "lookup failed", Err: nested}, "users.Get: lookup failed: db.Query: connection refused"},
|
|
{"empty fields", &Error{}, ""},
|
|
{"msg only", &Error{Msg: "boom"}, "boom"},
|
|
{"err only", &Error{Err: plain}, "connection refused"},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if got := tt.err.Error(); got != tt.want {
|
|
t.Errorf("Error() = %q, want %q", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestNew(t *testing.T) {
|
|
err := New("users.Get", "boom").(*Error)
|
|
if err.Op != "users.Get" || err.Msg != "boom" || err.Err != nil {
|
|
t.Errorf("unexpected fields: %+v", err)
|
|
}
|
|
}
|
|
|
|
func TestNewf(t *testing.T) {
|
|
err := Newf("users.Get", "user=%d", 42).(*Error)
|
|
if err.Op != "users.Get" || err.Msg != "user=42" || err.Err != nil {
|
|
t.Errorf("unexpected fields: %+v", err)
|
|
}
|
|
}
|
|
|
|
func TestWrap(t *testing.T) {
|
|
if got := Wrap("users.Get", nil); got != nil {
|
|
t.Errorf("Wrap(_, nil) = %v, want nil", got)
|
|
}
|
|
|
|
inner := errors.New("boom")
|
|
got := Wrap("users.Get", inner).(*Error)
|
|
if got.Op != "users.Get" || got.Msg != "" || got.Err != inner {
|
|
t.Errorf("unexpected fields: %+v", got)
|
|
}
|
|
}
|
|
|
|
func TestWrapf(t *testing.T) {
|
|
if got := Wrapf("users.Get", nil, "user=%d", 42); got != nil {
|
|
t.Errorf("Wrapf(_, nil, ...) = %v, want nil", got)
|
|
}
|
|
|
|
inner := errors.New("boom")
|
|
got := Wrapf("users.Get", inner, "user=%d", 42).(*Error)
|
|
if got.Op != "users.Get" || got.Msg != "user=42" || got.Err != inner {
|
|
t.Errorf("unexpected fields: %+v", got)
|
|
}
|
|
}
|
|
|
|
var sentinel = errors.New("sentinel")
|
|
|
|
func TestErrorsIs(t *testing.T) {
|
|
wrapped := Wrap("a.A", Wrap("b.B", Wrap("c.C", sentinel)))
|
|
if !errors.Is(wrapped, sentinel) {
|
|
t.Errorf("errors.Is did not find sentinel in chain: %v", wrapped)
|
|
}
|
|
if errors.Is(wrapped, io.EOF) {
|
|
t.Errorf("errors.Is matched unrelated sentinel")
|
|
}
|
|
}
|
|
|
|
func TestErrorsAs(t *testing.T) {
|
|
wrapped := Wrap("a.A", Wrap("b.B", Wrap("c.C", io.EOF)))
|
|
var target *Error
|
|
if !errors.As(wrapped, &target) {
|
|
t.Fatalf("errors.As did not find *Error in chain")
|
|
}
|
|
if target.Op != "a.A" {
|
|
t.Errorf("errors.As bound %q, want outermost %q", target.Op, "a.A")
|
|
}
|
|
}
|
|
|
|
func TestNestedChainFormat(t *testing.T) {
|
|
err := Wrap("a.A", Wrap("b.B", Wrap("c.C", io.EOF)))
|
|
want := "a.A: b.B: c.C: EOF"
|
|
if got := err.Error(); got != want {
|
|
t.Errorf("Error() = %q, want %q", got, want)
|
|
}
|
|
}
|