add errno

Author: thinkeridea

errno/convert.go

@@ -0,0 +1,41 @@
+// MIT License
+// Copyright (c) 2020 Qi Yin <[email protected]>
+
+package errno
+
+import (
+	"errors"
+)
+
+var (
+	// InternalServerError 系统错误，非 Errno 实现均被 Parse 解析为系统错误
+	InternalServerError = &errno{code: -1, message: "System Error"}
+
+	// OK error 为nil 时会被 Parse 解析为 OK
+	OK = &errno{code: 0, message: "ok"}
+)
+
+// To 把任意 error 转成 Errno 类型
+// 如果 err 实现了 Errno 接口，则返回 err 本身
+// 如果 err 为 nil， 返回预定义 OK， 默认 code=0, message=ok
+// 如果 err 没有实现 Errno，返回预定义 InternalServerError，并使用 WrapErrno 包装 err，默认 code=-1, message=System Error
+func To(err error) Errno {
+	if err == nil {
+		return OK
+	}
+
+	switch e := err.(type) {
+	case Errno:
+		return e
+	}
+
+	return Wrap(InternalServerError).Err(err)
+}
+
+// Parse 返回错误码、错误消息以及包装错误
+// Parse 首先使用 To(err) 获得一个 Errno 实现
+// 包装错误使用  errors.Unwrap 解析获得
+func Parse(err error) (int, string, error) {
+	w := To(err)
+	return w.Code(), w.Message(), errors.Unwrap(w)
+}

errno/convert_test.go

@@ -0,0 +1,84 @@
+package errno
+
+import (
+	"bytes"
+	"errors"
+	"os"
+	"testing"
+)
+
+func TestTo(t *testing.T) {
+	systemErr := errors.New("system error")
+	wrapE := errors.New("wrap error")
+	for _, v := range []struct {
+		err     error
+		code    int
+		message string
+		wrapErr error
+	}{
+		{systemErr, -1, "System Error", systemErr},
+		{systemErr, -1, "System Error", InternalServerError},
+		{os.ErrNotExist, -1, "System Error", os.ErrNotExist},
+		{bytes.ErrTooLarge, -1, "System Error", bytes.ErrTooLarge},
+		{nil, 0, "ok", OK},
+		{New(10, "testing"), 10, "testing", nil},
+		{NewCode(20), 20, "", nil},
+		{Wrap(New(10, "testing")).Comment("error comment"), 10, "testing: error comment", nil},
+		{Wrap(New(10, "testing")).Err(wrapE), 10, "testing", wrapE},
+		{Wrap(New(10, "testing %s")).Err(wrapE).Format("format"), 10, "testing format", wrapE},
+	} {
+		err := To(v.err)
+		if err.Code() != v.code {
+			t.Errorf("To(v.err).Code():%d != v.code:%d", err.Code(), v.code)
+		}
+
+		if err.Message() != v.message {
+			t.Errorf("To(v.err).Message():%s != v.message:%s", err.Message(), v.message)
+		}
+
+		if v.wrapErr != nil && !errors.Is(err, v.wrapErr) {
+			t.Errorf("errors.Is(err, v.wrapErr:%v) != true", v.wrapErr)
+		}
+	}
+}
+
+func TestParse(t *testing.T) {
+	systemErr := errors.New("system error")
+	wrapE := errors.New("wrap error")
+	for _, v := range []struct {
+		err     error
+		code    int
+		message string
+		wrapErr error
+	}{
+		{systemErr, -1, "System Error", systemErr},
+		{systemErr, -1, "System Error", InternalServerError},
+		{os.ErrNotExist, -1, "System Error", os.ErrNotExist},
+		{bytes.ErrTooLarge, -1, "System Error", bytes.ErrTooLarge},
+		{nil, 0, "ok", nil},
+		{New(10, "testing"), 10, "testing", nil},
+		{NewCode(20), 20, "", nil},
+		{Wrap(New(10, "testing")).Comment("error comment"), 10, "testing: error comment", nil},
+		{Wrap(New(10, "testing")).Err(wrapE), 10, "testing", wrapE},
+		{Wrap(New(10, "testing %s")).Err(wrapE).Format("format"), 10, "testing format", wrapE},
+	} {
+		t.Run("", func(t *testing.T) {
+			code, message, err := Parse(v.err)
+			if code != v.code {
+				t.Errorf("code:%d != v.code:%d", code, v.code)
+			}
+
+			if message != v.message {
+				t.Errorf("message:%s != v.message:%s", message, v.message)
+			}
+
+			if v.wrapErr != nil && !errors.Is(err, v.wrapErr) {
+				t.Errorf("errors.Is(err:%v, v.wrapErr:%v) != true", err, v.wrapErr)
+			}
+
+			if _, ok := v.wrapErr.(Errno); !ok && v.wrapErr != nil && errors.Unwrap(err) != v.wrapErr {
+				t.Errorf("errors.Unwrap(err:%v)!=v.wrapErr:%v", err, v.wrapErr)
+			}
+		})
+	}
+}

errno/errno.go

@@ -0,0 +1,52 @@
+// MIT License
+// Copyright (c) 2020 Qi Yin <[email protected]>
+
+package errno
+
+import (
+	"fmt"
+)
+
+// Errno 包含错误码和错误消息的接口，适用于应用程序错误
+type Errno interface {
+	error
+
+	// Code 返回错误编码
+	Code() int
+
+	// Message 返回错误消息文本
+	Message() string
+}
+
+// errno 包含错误码和错误消息，适用于应用程序错误
+type errno struct {
+	code    int
+	message string
+}
+
+// Code 返回错误编码
+func (e *errno) Code() int {
+	return e.code
+}
+
+// Message 返回错误消息文本
+func (e *errno) Message() string {
+	return e.message
+}
+
+// Error error 接口实现，格式化 Errno 信息
+func (e *errno) Error() string {
+	return fmt.Sprintf("Error - code: %d, message: %s", e.code, e.message)
+}
+
+// New 给定错误码及错误格式化文本，返回一个 Errno
+// 每 New 一次返回一个新的 Errno， 即使 code 和 message 相同
+func New(code int, message string) Errno {
+	return &errno{code: code, message: message}
+}
+
+// NewCode 给定错误码，返回一个 Errno
+// 每 New 一次返回一个新的 Errno， 即使 code 相同
+func NewCode(code int) Errno {
+	return &errno{code: code}
+}

errno/errno_test.go

@@ -0,0 +1,121 @@
+package errno
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestNew(t *testing.T) {
+	t1 := New(0, "ok")
+	t2 := New(0, "ok")
+	t3 := New(-1, "message")
+
+	if t1 == t2 {
+		t.Errorf("multiple New returns the same instance %p == %p", t1, t2)
+	}
+
+	if e, ok := t1.(*errno); !ok {
+		t.Error("t1  is not an instance of *errno")
+	} else if e.code != 0 {
+		t.Errorf("t1.code %d != 0", e.code)
+	} else if e.message != "ok" {
+		t.Errorf("t1.message %s != ok", e.message)
+	}
+
+	if e, ok := t2.(*errno); !ok {
+		t.Error("t2  is not an instance of *errno")
+	} else if e.code != 0 {
+		t.Errorf("t2.code %d != 0", e.code)
+	} else if e.message != "ok" {
+		t.Errorf("t2.message %s != ok", e.message)
+	}
+
+	if e, ok := t3.(*errno); !ok {
+		t.Error("t3  is not an instance of *errno")
+	} else if e.code != -1 {
+		t.Errorf("t3.code %d != -1", e.code)
+	} else if e.message != "message" {
+		t.Errorf("t3.message %s != message", e.message)
+	}
+}
+
+func TestNewCode(t *testing.T) {
+	t1 := NewCode(0)
+	t2 := NewCode(0)
+	t3 := NewCode(-1)
+
+	if t1 == t2 {
+		t.Errorf("multiple NewCode returns the same instance %p == %p", t1, t2)
+	}
+
+	if e, ok := t1.(*errno); !ok {
+		t.Error("t1  is not an instance of *errno")
+	} else if e.code != 0 {
+		t.Errorf("t1.code %d != 0", e.code)
+	} else if e.message != "" {
+		t.Errorf("t1.message %s not empty", e.message)
+	}
+
+	if e, ok := t2.(*errno); !ok {
+		t.Error("t2  is not an instance of *errno")
+	} else if e.code != 0 {
+		t.Errorf("t2.code %d != 0", e.code)
+	} else if e.message != "" {
+		t.Errorf("t2.message %s not empty ", e.message)
+	}
+
+	if e, ok := t3.(*errno); !ok {
+		t.Error("t3  is not an instance of *errno")
+	} else if e.code != -1 {
+		t.Errorf("t3.code %d != -1", e.code)
+	} else if e.message != "" {
+		t.Errorf("t3.message %s not empty", e.message)
+	}
+}
+
+func TestErrno_Code(t *testing.T) {
+	t1 := NewCode(1)
+	t2 := NewCode(2)
+	t3 := NewCode(-1)
+
+	if t1.Code() != 1 {
+		t.Errorf("t1.Code() %d != 1", t1.Code())
+	}
+
+	if t2.Code() != 2 {
+		t.Errorf("t2.Code() %d != 2", t2.Code())
+	}
+
+	if t3.Code() != -1 {
+		t.Errorf("t3.Code() %d != -1", t3.Code())
+	}
+}
+
+func TestErrno_Message(t *testing.T) {
+	t1 := New(1, "Error Message 1")
+	t2 := New(2, "Error Message 2")
+	t3 := New(-1, "System Error")
+
+	if t1.Message() != "Error Message 1" {
+		t.Errorf("t1.Message() %s != 'Error Message 1'", t1.Message())
+	}
+
+	if t2.Message() != "Error Message 2" {
+		t.Errorf("t2.Message() %s != 'Error Message 2'", t2.Message())
+	}
+
+	if t3.Message() != "System Error" {
+		t.Errorf("t3.Message() %s != 'System Error'", t3.Message())
+	}
+}
+
+func TestErrno_Error(t *testing.T) {
+	err := New(-1, "System Error")
+	if err.Error() != "Error - code: -1, message: System Error" {
+		t.Errorf("err.Error():'%s' != 'Error - code: -1, message: System Error'", err.Error())
+	}
+
+	if fmt.Sprintf("%v", err) != "Error - code: -1, message: System Error" {
+		t.Errorf("fmt.Sprintf(\"%%v\", err):'%s' != 'Error - code: -1, message: System Error'", fmt.Sprintf("%v", err))
+	}
+}

errno/error.go

@@ -0,0 +1,78 @@
+package errno
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+)
+
+type wrapError struct {
+	old *wrapError
+	new error
+	msg string
+}
+
+func (w *wrapError) Wrap(err error) *wrapError {
+	if err == nil {
+		return w
+	}
+
+	// 第一层错误为 Errno，不设置msg
+	if w == nil {
+		if _, ok := err.(Errno); ok {
+			return &wrapError{new: err}
+		}
+	}
+
+	var msg string
+	if w == nil || w.msg == "" {
+		msg = fmt.Sprintf("%v", err)
+	} else {
+		msg = fmt.Sprintf("%s, %v", w.msg, err)
+	}
+
+	return &wrapError{old: w, new: err, msg: msg}
+}
+
+func (w *wrapError) Error() string {
+	if w == nil {
+		return ""
+	}
+	return w.msg
+}
+
+func (w *wrapError) Is(target error) bool {
+	if w == target {
+		return true
+	}
+	for w != nil {
+		if errors.Is(w.new, target) {
+			return true
+		}
+
+		w = w.old
+	}
+
+	return false
+}
+
+func (w *wrapError) As(target interface{}) bool {
+	for w != nil {
+		if errors.As(w.new, target) {
+			return true
+		}
+
+		w = w.old
+	}
+
+	return false
+}
+
+func (w *wrapError) Unwrap() error {
+	if w == nil {
+		return nil
+	}
+	return w.new
+}
+
+var errorType = reflect.TypeOf((*error)(nil)).Elem()