errors_test.go

package itglue

import (
	"errors"
	"testing"
	"time"
)

func TestError_Interface(t *testing.T) {
	err := Error{Code: 404, Message: "Not found", Type: "not_found"}

	if err.Error() != "itglue: Not found (code: 404)" {
		t.Errorf("Unexpected error string: %s", err.Error())
	}

	// Test that it implements error interface
	var _ error = err
}

func TestRateLimitError_RetryAfter(t *testing.T) {
	err := RateLimitError{
		BaseError:  Error{Code: 429, Message: "Rate limit exceeded", Type: "rate_limit"},
		RetryAfter: 30 * time.Second,
	}

	expected := "itglue: rate limit exceeded, retry after 30s"
	if err.Error() != expected {
		t.Errorf("Expected %q, got %q", expected, err.Error())
	}
}

func TestValidationError_Message(t *testing.T) {
	err := ValidationError{
		BaseError: Error{Code: 422, Message: "Validation failed", Type: "validation"},
		Field:     "email",
		Reason:    "invalid format",
	}

	expected := "itglue: validation error on field 'email': invalid format"
	if err.Error() != expected {
		t.Errorf("Expected %q, got %q", expected, err.Error())
	}
}

func TestAuthError_Message(t *testing.T) {
	err := AuthError{
		BaseError: Error{Code: 401, Message: "Unauthorized", Type: "auth"},
	}

	expected := "itglue: authentication failed - invalid or expired API key"
	if err.Error() != expected {
		t.Errorf("Expected %q, got %q", expected, err.Error())
	}
}

func TestNotFoundError_Message(t *testing.T) {
	err := NotFoundError{
		BaseError:    Error{Code: 404, Message: "Not found", Type: "not_found"},
		ResourceType: "organization",
		ResourceID:   "123",
	}

	expected := "itglue: organization with id '123' not found"
	if err.Error() != expected {
		t.Errorf("Expected %q, got %q", expected, err.Error())
	}
}

func TestErrors_Is_MatchesSentinels(t *testing.T) {
	// handleErrorResponse always returns pointers, so exercise the same
	// shape here: errors.Is must unwrap through the pointer to the sentinel.
	tests := []struct {
		name     string
		err      error
		sentinel error
	}{
		{"AuthError -> ErrUnauthorized", &AuthError{BaseError: Error{Code: 401}}, ErrUnauthorized},
		{"ForbiddenError -> ErrForbidden", &ForbiddenError{BaseError: Error{Code: 403}}, ErrForbidden},
		{"NotFoundError -> ErrNotFound", &NotFoundError{BaseError: Error{Code: 404}}, ErrNotFound},
		{"RateLimitError -> ErrRateLimited", &RateLimitError{BaseError: Error{Code: 429}}, ErrRateLimited},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if !errors.Is(tt.err, tt.sentinel) {
				t.Errorf("errors.Is(%T, %v) = false, want true", tt.err, tt.sentinel)
			}
		})
	}

	// Sanity check: unrelated sentinels must not match.
	if errors.Is(&AuthError{}, ErrNotFound) {
		t.Error("errors.Is(*AuthError, ErrNotFound) = true, want false")
	}
}

func TestAPIError_Message(t *testing.T) {
	err := APIError{
		BaseError: Error{Code: 400, Message: "Bad request", Type: "api"},
		Errors:    []ErrorDetail{}, // Empty for this test
	}

	expected := "itglue: Bad request (code: 400)"
	if err.Error() != expected {
		t.Errorf("Expected %q, got %q", expected, err.Error())
	}
}