func_query_test.go

package xerror_test

import (
	"errors"
	"testing"

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

func TestCause(t *testing.T) {
	// 单层 XError：无 cause
	err := xerror.New("base")
	if xerror.Cause(err) != nil {
		t.Fatal("single XError should have no cause")
	}

	// 两层 Wrap：Cause 返回业务层内部错误
	inner := xerror.NewCode(100001, "内部错误")
	wrapped := xerror.Wrap(inner, "外部错误")
	cause := xerror.Cause(wrapped)
	if cause == nil {
		t.Fatal("wrapped error should have a cause")
	}

	// Cause 返回 error，需用 AsXError 提取 XError
	xe, ok := xerror.AsXError(cause)
	if !ok {
		t.Fatal("cause should be extractable as XError")
	}
	if xe.ErrorCode() != 100001 {
		t.Fatalf("cause should have code 100001, got %d", xe.ErrorCode())
	}

	// 非 XError 输入
	if xerror.Cause(errors.New("plain")) != nil {
		t.Fatal("plain error should return nil cause")
	}

	// 混合 error 链：XError 包装标准 error
	plainErr := errors.New("plain inner")
	wrappedPlain := xerror.Wrap(plainErr, "wrap plain")
	cause2 := xerror.Cause(wrappedPlain)
	if cause2 == nil {
		t.Fatal("wrapped plain error should have a cause")
	}
	if cause2.Error() != "plain inner" {
		t.Fatalf("cause should be 'plain inner', got %q", cause2.Error())
	}

	// WrapStatus：直接存储原始 error，Cause 应正确返回
	wrappedStatus := xerror.WrapStatus(inner, xcode.Forbidden)
	cause3 := xerror.Cause(wrappedStatus)
	if cause3 == nil {
		t.Fatal("WrapStatus wrapped error should have a cause")
	}
	xe3, ok3 := xerror.AsXError(cause3)
	if !ok3 {
		t.Fatal("cause of WrapStatus should be extractable as XError")
	}
	if xe3.ErrorCode() != 100001 {
		t.Fatalf("cause should have code 100001, got %d", xe3.ErrorCode())
	}
}

func TestRootCause(t *testing.T) {
	// 单层 XError：root 就是 Unwrap 链的最底层
	err := xerror.New("base")
	root := xerror.RootCause(err)
	if root == nil {
		t.Fatal("single XError should have root cause")
	}

	// 多层 Wrap
	inner := xerror.NewCode(100001, "内部错误")
	wrapped := xerror.Wrap(inner, "外部错误")
	doubleWrapped := xerror.Wrap(wrapped, "最外层")
	root = xerror.RootCause(doubleWrapped)
	if root == nil {
		t.Fatal("should have root cause")
	}

	// RootCause 返回 error，用 AsXError 提取
	xe, ok := xerror.AsXError(root)
	if !ok {
		t.Fatal("root cause should be extractable as XError in pure XError chain")
	}
	if xe.ErrorCode() != 100001 {
		t.Fatalf("root cause should have code 100001, got %d", xe.ErrorCode())
	}

	// 非 XError 输入
	plainRoot := xerror.RootCause(errors.New("plain"))
	if plainRoot == nil {
		t.Fatal("plain error should return itself as root")
	}
	if plainRoot.Error() != "plain" {
		t.Fatalf("plain root should be 'plain', got %q", plainRoot.Error())
	}
}

func TestRootCause_JoinedError(t *testing.T) {
	inner := xerror.NewCode(100001, "根因")
	joined := errors.Join(inner, errors.New("other"))
	root := xerror.RootCause(joined)
	if root == nil {
		t.Fatal("RootCause should find root in joined error chain")
	}
}

func TestAsXError(t *testing.T) {
	// XError 输入
	err := xerror.NewCode(403, "forbidden")
	xe, ok := xerror.AsXError(err)
	if !ok {
		t.Fatal("AsXError should extract XError")
	}
	if xe.ErrorCode() != 403 {
		t.Fatalf("expected code 403, got %d", xe.ErrorCode())
	}

	// 标准 error 输入
	_, ok = xerror.AsXError(errors.New("plain"))
	if ok {
		t.Fatal("AsXError should return false for plain error")
	}

	// 包装后的 XError 也能提取
	wrapped := xerror.Wrap(err, "wrapped")
	xe2, ok2 := xerror.AsXError(wrapped)
	if !ok2 {
		t.Fatal("AsXError should extract from wrapped XError")
	}
	if xe2.ErrorCode() != 403 {
		t.Fatalf("expected code 403, got %d", xe2.ErrorCode())
	}
}