add errx

errx_test.go

@@ -0,0 +1,104 @@
+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)
+	}
+}