func_test.go

package xerror_test

import (
	"errors"
	"fmt"
	"net/http"
	"testing"

	"github.com/gomooth/xerror"
	"github.com/gomooth/xerror/xcode"
)

func TestNew(t *testing.T) {
	err := xerror.New("this is new error")
	if err.Message() != "this is new error" {
		t.Fatalf("expected 'this is new error', got %q", err.Message())
	}
	if err.ErrorCode() != xcode.CodeNone {
		t.Fatalf("New() should default to CodeNone(0), got %d", err.ErrorCode())
	}
}

func TestNewCode(t *testing.T) {
	err := xerror.NewCode(100001, "未登录")
	if err.ErrorCode() != 100001 {
		t.Fatalf("expected code 100001, got %d", err.ErrorCode())
	}
	if err.Message() != "未登录" {
		t.Fatalf("expected '未登录', got %q", err.Message())
	}

	msg := err.ToMessage(nil)
	if msg != "未登录" {
		t.Fatalf("expected '未登录', got %q", msg)
	}
}

func TestNewCodef(t *testing.T) {
	err := xerror.NewCodef(100002, "用户 %s 不存在", "test")
	if err.Message() != "用户 test 不存在" {
		t.Fatalf("expected '用户 test 不存在', got %q", err.Message())
	}
}

func TestNewXCode(t *testing.T) {
	err := xerror.NewXCode(xcode.InternalServerError)
	if err.ErrorCode() != xcode.InternalServerError.Code() {
		t.Fatalf("expected %d, got %d", xcode.InternalServerError.Code(), err.ErrorCode())
	}
}

func TestNewXCode_withMessage(t *testing.T) {
	err := xerror.NewXCode(xcode.InternalServerError, "变更消息")
	if err.Message() != "变更消息" {
		t.Fatalf("expected '变更消息', got %q", err.Message())
	}
}

func TestParsePayload(t *testing.T) {
	// 无 fields
	err := xerror.NewXCode(xcode.InternalServerError, "变更消息")
	payload := xerror.ParsePayload(err)
	if payload != nil {
		t.Fatalf("expected nil payload, got %v", payload)
	}

	// 有 fields
	err2 := xerror.Wrap(err, "错误2").
		WithFields(xerror.F("name", "abc")).
		WithFields(
			xerror.F("k", "v"),
			xerror.F("a", 1),
		)
	payload2 := xerror.ParsePayload(err2)
	if payload2 == nil {
		t.Fatal("expected non-nil payload")
	}
	if payload2["name"] != "abc" {
		t.Fatalf("expected name=abc, got %v", payload2["name"])
	}

	plainErr := errors.New("plain")
	if xerror.ParsePayload(plainErr) != nil {
		t.Fatal("plain error should return nil")
	}
}

func TestFormatStackTrace(t *testing.T) {
	err := xerror.NewXCode(xcode.InternalServerError, "变更消息")
	trace := fmt.Sprintf("%+v", err)
	if len(trace) == 0 {
		t.Fatal("FormatStackTrace should not be empty")
	}
}

func TestStackTrace(t *testing.T) {
	err := xerror.NewCode(403, "forbidden")
	trace := xerror.StackTrace(err)
	if len(trace) == 0 {
		t.Fatal("StackTrace should not be empty for XError")
	}
}

func TestStackTrace_PlainError(t *testing.T) {
	err := errors.New("plain")
	trace := xerror.StackTrace(err)
	if trace != "" {
		t.Fatalf("plain error should have empty stack trace, got %q", trace)
	}
}

func TestFormatMsg(t *testing.T) {
	err := xerror.NewCode(100001, "未登录")
	msg := xerror.FormatMsg(err)
	if msg != "[100001] 未登录" {
		t.Fatalf("expected '[100001] 未登录', got %q", msg)
	}

	// 非 XError
	plainErr := error(newPlainError("plain"))
	msg2 := xerror.FormatMsg(plainErr)
	if msg2 != "plain" {
		t.Fatalf("expected 'plain', got %q", msg2)
	}
}

type plainError string

func (e plainError) Error() string { return string(e) }

func newPlainError(s string) error { return plainError(s) }

type testCustomCode struct {
	httpStatus int
	code       int
	message    string
}

func (c *testCustomCode) Code() int       { return c.code }
func (c *testCustomCode) HttpStatus() int { return c.httpStatus }
func (c *testCustomCode) String() string  { return c.message }

func TestWrapPreservesHTTPStatus(t *testing.T) {
	// 仓库中的 code
	err1 := xerror.NewXCode(xcode.RequestParamError) // httpStatus=400
	werr1 := xerror.Wrap(err1, "wrapped")
	if werr1.HttpStatus() != 400 {
		t.Fatalf("expected httpStatus 400 for repo code, got %d", werr1.HttpStatus())
	}

	// 仓库中不存在的 code，但原始 XCode 有自定义 httpStatus
	cc := &testCustomCode{httpStatus: 400, code: 999999, message: "自定义错误"}
	err2 := xerror.NewXCode(cc)
	werr2 := xerror.Wrap(err2, "wrapped")
	if werr2.HttpStatus() != 400 {
		t.Fatalf("expected httpStatus 400 for custom code, got %d", werr2.HttpStatus())
	}

	// Wrap 保留原始 code
	if werr2.ErrorCode() != 999999 {
		t.Fatalf("expected code 999999, got %d", werr2.ErrorCode())
	}

	// Wrap 保留原始 httpStatus 但更新消息
	if werr2.Message() != "wrapped" {
		t.Fatalf("expected Message() 'wrapped', got %q", werr2.Message())
	}
}

func TestWrap_OverridePropagation(t *testing.T) {
	// 先创建错误
	err := xerror.NewXCode(xcode.Forbidden) // code=403, httpStatus=403

	// Override 改变 httpStatus
	xcode.Override(403, http.StatusMethodNotAllowed, "覆写403")
	defer xcode.Reset()

	// Wrap 后应保留原始 XError 的 httpStatus（即 Override 前的 403），
	// 而不是使用 Override 后的 httpStatus
	wrapped := xerror.Wrap(err, "wrapped")
	if wrapped.HttpStatus() != http.StatusForbidden {
		t.Fatalf("expected original httpStatus %d, got %d", http.StatusForbidden, wrapped.HttpStatus())
	}
	if wrapped.ErrorCode() != 403 {
		t.Fatalf("expected code 403, got %d", wrapped.ErrorCode())
	}
}

func TestWrapPreservesErrorChain(t *testing.T) {
	inner := xerror.NewXCode(xcode.RequestParamError) // code=400
	wrapped := xerror.Wrap(inner, "wrapped")

	// Unwrap 后应能找到原始 XError
	unwrapped := wrapped.Unwrap()
	var found xerror.XError
	if !errors.As(unwrapped, &found) {
		t.Fatal("expected to find XError in unwrap chain")
	}
	if found.ErrorCode() != 400 {
		t.Fatalf("expected unwrapped XError code 400, got %d", found.ErrorCode())
	}

	// IsErrorCode 应能找到内部 code
	if !xerror.IsErrorCode(wrapped, 400) {
		t.Fatal("expected IsErrorCode to find code 400 in chain")
	}
}

func TestNewDefaultCode(t *testing.T) {
	err := xerror.New("简单错误")
	if err.ErrorCode() != xcode.CodeNone {
		t.Fatalf("New() should use CodeNone(%d), got %d", xcode.CodeNone, err.ErrorCode())
	}
	if err.HttpStatus() != 500 {
		t.Fatalf("New() httpStatus should be 500, got %d", err.HttpStatus())
	}
	if err.Message() != "简单错误" {
		t.Fatalf("New() Message() should be '简单错误', got %q", err.Message())
	}
}

func TestIs_Semantic(t *testing.T) {
	// 同 code：应匹配（同码即同类，标准 errors.Is 语义）
	err1 := xerror.NewCode(1001, "数据库错误")
	err2 := xerror.NewCode(1001, "Database error")
	if !err1.Is(err2) {
		t.Fatal("same code should be Is-equal (kind semantics)")
	}

	// 不同 code：不应匹配
	err3 := xerror.NewCode(1001, "数据库错误")
	err4 := xerror.NewCode(1002, "数据库错误")
	if err3.Is(err4) {
		t.Fatal("different code should not be Is-equal")
	}

	// CodeNone：不同实例不匹配（即使消息相同）
	err5 := xerror.New("数据库连接失败")
	err6 := xerror.New("数据库连接失败")
	if err5.Is(err6) {
		t.Fatal("CodeNone XErrors should not be Is-equal (independent errors)")
	}

	// CodeNone 与自身匹配
	if !err5.Is(err5) {
		t.Fatal("CodeNone XError should match itself")
	}

	// CodeNone + 不同消息：不应匹配
	err7 := xerror.New("数据库连接失败")
	err8 := xerror.New("用户不存在")
	if err7.Is(err8) {
		t.Fatal("CodeNone with different message should not be Is-equal")
	}

	// CodeNone vs 有业务码：不应匹配
	err9 := xerror.New("错误")
	err10 := xerror.NewCode(1001, "错误")
	if err9.Is(err10) {
		t.Fatal("CodeNone vs non-CodeNone should not be Is-equal")
	}
}

func TestWrapWithCodePreservesMessage(t *testing.T) {
	err := errors.New("原始错误")
	werr := xerror.WrapWithCode(err, 3333)
	if werr.Message() != "原始错误" {
		t.Fatalf("expected Message() '原始错误', got %q", werr.Message())
	}
	if werr.ErrorCode() != 3333 {
		t.Fatalf("expected code 3333, got %d", werr.ErrorCode())
	}
}

func TestFormatConsistency(t *testing.T) {
	err := xerror.NewCode(1001, "数据库错误")

	// %v 应等同于 Error()
	if fmt.Sprintf("%v", err) != err.Error() {
		t.Fatalf("%%v should equal Error(): got %q vs %q", fmt.Sprintf("%v", err), err.Error())
	}

	// %s 应等同于 Error()
	if fmt.Sprintf("%s", err) != err.Error() {
		t.Fatalf("%%s should equal Error(): got %q vs %q", fmt.Sprintf("%s", err), err.Error())
	}

	// %+v 应包含栈信息
	detailed := fmt.Sprintf("%+v", err)
	if len(detailed) == 0 {
		t.Fatalf("%%+v should not be empty")
	}

	// FormatMsg 应包含 [code] 前缀
	msg := xerror.FormatMsg(err)
	if msg != "[1001] 数据库错误" {
		t.Fatalf("FormatMsg should be '[1001] 数据库错误', got %q", msg)
	}
}

func TestMessage(t *testing.T) {
	// 单层错误：Message() == Error()
	err := xerror.New("简单错误")
	if err.Message() != "简单错误" {
		t.Fatalf("expected Message() '简单错误', got %q", err.Message())
	}
	if err.Message() != err.Error() {
		t.Fatalf("Message() should equal Error() for single-layer error")
	}

	// 包装后：Message() != Error()
	inner := xerror.New("原始错误")
	wrapped := xerror.Wrap(inner, "包装错误")
	if wrapped.Message() != "包装错误" {
		t.Fatalf("expected Message() '包装错误', got %q", wrapped.Message())
	}
	// Error() 包含完整链
	if wrapped.Error() == "包装错误" {
		t.Fatal("Error() should contain chain context, not just Message()")
	}

	// NewCode 的 Message()
	codeErr := xerror.NewCode(1001, "数据库错误")
	if codeErr.Message() != "数据库错误" {
		t.Fatalf("expected Message() '数据库错误', got %q", codeErr.Message())
	}

	// nil code 降级
	xcErr := xerror.NewXCode(nil) // 降级为 InternalServerError
	if xcErr.Message() != xcode.InternalServerError.String() {
		t.Fatalf("expected Message() fallback to InternalServerError, got %q", xcErr.Message())
	}
}

func TestErrorf_WithoutPercentW(t *testing.T) {
	err := xerror.Errorf("simple %s", "error")
	if err.Message() != "simple error" {
		t.Fatalf("expected 'simple error', got %q", err.Message())
	}
}

func TestNewXCodef(t *testing.T) {
	err := xerror.NewXCodef(xcode.InternalServerError, "user %s not found, code: %d", "test", 404)
	if err.Message() != "user test not found, code: 404" {
		t.Fatalf("expected 'user test not found, code: 404', got %q", err.Message())
	}
	if err.ErrorCode() != xcode.InternalServerError.Code() {
		t.Fatalf("expected code %d, got %d", xcode.InternalServerError.Code(), err.ErrorCode())
	}
}