errors_test.go

package ramp_test

import (
	"errors"
	"testing"

	ramp "github.com/iamkanishka/ramp-go"
)

func TestError_Error_WithHTTPStatus(t *testing.T) {
	e := &ramp.Error{
		Type:       ramp.ErrorTypeNotFound,
		Message:    "user not found",
		StatusCode: 404,
		TraceID:    "trace-abc",
	}
	got := e.Error()
	for _, want := range []string{"not_found", "404", "user not found", "trace-abc"} {
		if !contains(got, want) {
			t.Errorf("Error() = %q, missing %q", got, want)
		}
	}
}

func TestError_Error_WithoutHTTPStatus(t *testing.T) {
	e := &ramp.Error{Type: ramp.ErrorTypeNetwork, Message: "connection refused"}
	got := e.Error()
	if !contains(got, "network_error") || !contains(got, "connection refused") {
		t.Errorf("Error() = %q, missing type or message", got)
	}
}

func TestError_IsRetryable(t *testing.T) {
	retryable := []ramp.ErrorType{
		ramp.ErrorTypeRateLimit,
		ramp.ErrorTypeServer,
		ramp.ErrorTypeNetwork,
	}
	for _, et := range retryable {
		e := &ramp.Error{Type: et}
		if !e.IsRetryable() {
			t.Errorf("IsRetryable(%q): got false, want true", et)
		}
	}

	nonRetryable := []ramp.ErrorType{
		ramp.ErrorTypeAuthentication,
		ramp.ErrorTypeAuthorization,
		ramp.ErrorTypeNotFound,
		ramp.ErrorTypeValidation,
		ramp.ErrorTypeTimeout,
		ramp.ErrorTypeDeferred,
		ramp.ErrorTypeUnknown,
	}
	for _, et := range nonRetryable {
		e := &ramp.Error{Type: et}
		if e.IsRetryable() {
			t.Errorf("IsRetryable(%q): got true, want false", et)
		}
	}
}

func TestAPIError_Maps400ToValidation(t *testing.T) {
	e := ramp.APIError(400, []byte(`{"message":"email is required"}`), "trace-1")
	if e.Type != ramp.ErrorTypeValidation {
		t.Errorf("type: got %q, want validation_error", e.Type)
	}
	if e.StatusCode != 400 {
		t.Errorf("status: got %d, want 400", e.StatusCode)
	}
	if e.Message != "email is required" {
		t.Errorf("message: got %q", e.Message)
	}
}

func TestAPIError_Maps401ToAuthentication(t *testing.T) {
	e := ramp.APIError(401, []byte(`{"message":"unauthorized"}`), "")
	if e.Type != ramp.ErrorTypeAuthentication {
		t.Errorf("type: got %q, want authentication_error", e.Type)
	}
}

func TestAPIError_Maps403ToAuthorization(t *testing.T) {
	e := ramp.APIError(403, []byte(`{"message":"forbidden"}`), "")
	if e.Type != ramp.ErrorTypeAuthorization {
		t.Errorf("type: got %q, want authorization_error", e.Type)
	}
}

func TestAPIError_Maps404ToNotFound(t *testing.T) {
	e := ramp.APIError(404, []byte(`{"message":"not found"}`), "")
	if e.Type != ramp.ErrorTypeNotFound {
		t.Errorf("type: got %q, want not_found", e.Type)
	}
}

func TestAPIError_Maps429ToRateLimit(t *testing.T) {
	e := ramp.APIError(429, []byte(`{"message":"too many requests","retry_after":30}`), "")
	if e.Type != ramp.ErrorTypeRateLimit {
		t.Errorf("type: got %q, want rate_limit_error", e.Type)
	}
	if e.RetryAfter != 30 {
		t.Errorf("RetryAfter: got %d, want 30", e.RetryAfter)
	}
}

func TestAPIError_Maps429_DefaultRetryAfter60(t *testing.T) {
	e := ramp.APIError(429, []byte(`{"message":"too many requests"}`), "")
	if e.RetryAfter != 60 {
		t.Errorf("RetryAfter: got %d, want 60 (default)", e.RetryAfter)
	}
}

func TestAPIError_Maps500ToServer(t *testing.T) {
	e := ramp.APIError(500, []byte(`{"message":"internal server error"}`), "trace-xyz")
	if e.Type != ramp.ErrorTypeServer {
		t.Errorf("type: got %q, want server_error", e.Type)
	}
	if e.TraceID != "trace-xyz" {
		t.Errorf("traceID: got %q, want trace-xyz", e.TraceID)
	}
}

func TestAPIError_Maps502To503To504ToServer(t *testing.T) {
	for _, code := range []int{502, 503, 504} {
		e := ramp.APIError(code, []byte(`{}`), "")
		if e.Type != ramp.ErrorTypeServer {
			t.Errorf("code %d: type: got %q, want server_error", code, e.Type)
		}
	}
}

func TestAPIError_FallsBackToErrorField(t *testing.T) {
	e := ramp.APIError(400, []byte(`{"error":"bad_request"}`), "")
	if e.Message != "bad_request" {
		t.Errorf("message: got %q, want bad_request", e.Message)
	}
}

func TestAPIError_FallsBackToHTTPStatusText(t *testing.T) {
	e := ramp.APIError(418, []byte(`{}`), "")
	if e.Message == "" {
		t.Error("message should not be empty")
	}
}

func TestAPIError_AttachesBody(t *testing.T) {
	body := []byte(`{"message":"error","extra":"data"}`)
	e := ramp.APIError(400, body, "")
	if string(e.Body) != string(body) {
		t.Errorf("body: got %q, want %q", e.Body, body)
	}
}

func TestIsNotFound_True(t *testing.T) {
	err := &ramp.Error{Type: ramp.ErrorTypeNotFound, StatusCode: 404, Message: "not found"}
	if !ramp.IsNotFound(err) {
		t.Error("IsNotFound: got false, want true")
	}
}

func TestIsNotFound_False(t *testing.T) {
	err := &ramp.Error{Type: ramp.ErrorTypeServer, StatusCode: 500, Message: "server error"}
	if ramp.IsNotFound(err) {
		t.Error("IsNotFound: got true, want false")
	}
}

func TestIsNotFound_NonRampError(t *testing.T) {
	if ramp.IsNotFound(errors.New("generic error")) {
		t.Error("IsNotFound: got true for non-ramp error")
	}
}

func TestIsNotFound_Nil(t *testing.T) {
	if ramp.IsNotFound(nil) {
		t.Error("IsNotFound(nil): got true, want false")
	}
}

func TestIsRateLimit(t *testing.T) {
	err := &ramp.Error{Type: ramp.ErrorTypeRateLimit, RetryAfter: 60}
	if !ramp.IsRateLimit(err) {
		t.Error("IsRateLimit: got false, want true")
	}
}

func TestIsAuth_Authentication(t *testing.T) {
	err := &ramp.Error{Type: ramp.ErrorTypeAuthentication}
	if !ramp.IsAuth(err) {
		t.Error("IsAuth(authentication): got false")
	}
}

func TestIsAuth_Authorization(t *testing.T) {
	err := &ramp.Error{Type: ramp.ErrorTypeAuthorization}
	if !ramp.IsAuth(err) {
		t.Error("IsAuth(authorization): got false")
	}
}

func TestIsValidation(t *testing.T) {
	err := &ramp.Error{Type: ramp.ErrorTypeValidation}
	if !ramp.IsValidation(err) {
		t.Error("IsValidation: got false, want true")
	}
}

func TestError_ImplementsErrorInterface(_ *testing.T) {
	var err error = &ramp.Error{Type: ramp.ErrorTypeNotFound, Message: "test"}
	_ = err.Error() // must not panic
}

func TestError_ErrorsAs(t *testing.T) {
	orig := &ramp.Error{Type: ramp.ErrorTypeServer, Message: "boom", StatusCode: 500}
	wrapped := errors.Join(errors.New("outer"), orig)

	var re *ramp.Error
	if !errors.As(wrapped, &re) {
		t.Fatal("errors.As failed")
	}
	if re.StatusCode != 500 {
		t.Errorf("StatusCode: got %d, want 500", re.StatusCode)
	}
}

func TestPtr_ReturnsPointerToValue(t *testing.T) {
	s := ramp.Ptr("hello")
	if *s != "hello" {
		t.Errorf("Ptr string: got %q", *s)
	}
	n := ramp.Ptr(42)
	if *n != 42 {
		t.Errorf("Ptr int: got %d", *n)
	}
	b := ramp.Ptr(true)
	if !*b {
		t.Error("Ptr bool: got false")
	}
}

func contains(s, sub string) bool {
	return len(s) >= len(sub) && (s == sub || len(s) > 0 && containsHelper(s, sub))
}

func containsHelper(s, sub string) bool {
	for i := 0; i <= len(s)-len(sub); i++ {
		if s[i:i+len(sub)] == sub {
			return true
		}
	}
	return false
}