CLIProxyAPI/internal/runtime/executor/claude_request_rate_test.go

package executor

import (
	"errors"
	"fmt"
	"net/http"
	"strconv"
	"testing"
	"time"
)

// Issue #6720: an explicit per-minute rate-limit error carrying a short
// Retry-After must not inherit a later unclassified unified reset when no
// status header declares a quota window. Fixtures are synthetic.

var claudePerMinuteMessages = []struct {
	name     string
	resource string
}{
	{name: "requests", resource: "requests"},
	{name: "input_tokens", resource: "input tokens"},
	{name: "output_tokens", resource: "output tokens"},
}

func claudePerMinuteBody(resource string) []byte {
	return []byte(fmt.Sprintf(
		`{"type":"error","error":{"type":"rate_limit_error","message":"This request would exceed the %s per minute rate limit. Please try again later."}}`,
		resource,
	))
}

func classifyClaudeRateTestError(t *testing.T, fast bool, headers http.Header, body []byte) time.Duration {
	t.Helper()
	var err error
	if fast {
		err = newClaudeFastDirectResponseError(&http.Response{StatusCode: http.StatusTooManyRequests, Header: headers}, body)
	} else {
		err = classifyClaudeUpstreamError(http.StatusTooManyRequests, headers, body)
	}
	if err == nil {
		t.Fatal("expected error, got nil")
	}
	var rap retryAfterProvider
	if !errors.As(err, &rap) || rap.RetryAfter() == nil {
		t.Fatalf("expected non-nil RetryAfter, got %v", err)
	}
	return *rap.RetryAfter()
}

func TestClaudePerMinuteRateLimitHonorsShortRetryAfter_Issue6720(t *testing.T) {
	for _, msg := range claudePerMinuteMessages {
		for _, fast := range []bool{false, true} {
			path := "standard"
			if fast {
				path = "fast_direct"
			}
			t.Run(msg.name+"/"+path, func(t *testing.T) {
				headers := http.Header{}
				headers.Set("Retry-After", "30")
				headers.Set("Anthropic-Ratelimit-Unified-Reset", strconv.FormatInt(time.Now().Add(4*time.Hour).Unix(), 10))

				got := classifyClaudeRateTestError(t, fast, headers, claudePerMinuteBody(msg.resource))
				// 30s hint plus the existing 1-30s bounded grace; allow clock slack.
				if got < 29*time.Second || got > 60*time.Second {
					t.Fatalf("RetryAfter = %v, want between 29s and 60s (must not inherit the 4h unified reset)", got)
				}
			})
		}
	}
}

func TestClaudePerMinuteRateLimitKeepsConservativeQuota_Issue6720(t *testing.T) {
	tests := []struct {
		name   string
		body   []byte
		mutate func(h http.Header)
	}{
		{
			name: "explicit unified status",
			body: claudePerMinuteBody("requests"),
			mutate: func(h http.Header) {
				h.Set("Anthropic-Ratelimit-Unified-Status", "rejected")
			},
		},
		{
			name: "unknown message wording",
			body: []byte(`{"type":"error","error":{"type":"rate_limit_error","message":"The requests per minute limit is mentioned for information only."}}`),
		},
		{
			name: "mixed quota message",
			body: []byte(`{"type":"error","error":{"type":"rate_limit_error","message":"This request would exceed the requests per minute rate limit. Please try again later. Your weekly usage quota is exhausted."}}`),
		},
		{
			name: "repeated retry-after values",
			body: claudePerMinuteBody("requests"),
			mutate: func(h http.Header) {
				h["Retry-After"] = []string{"30", "14400"}
			},
		},
		{
			name: "missing retry-after",
			body: claudePerMinuteBody("requests"),
			mutate: func(h http.Header) {
				h.Del("Retry-After")
			},
		},
		{
			name: "malformed body",
			body: []byte(`{"type":"error","error":{"type":"rate_limit_error","message":"This request would exceed the requests per minute rate limit. Please try again later."}`),
		},
	}

	for _, tt := range tests {
		for _, fast := range []bool{false, true} {
			path := "standard"
			if fast {
				path = "fast_direct"
			}
			t.Run(tt.name+"/"+path, func(t *testing.T) {
				headers := http.Header{}
				headers.Set("Retry-After", "30")
				headers.Set("Anthropic-Ratelimit-Unified-Reset", strconv.FormatInt(time.Now().Add(4*time.Hour).Unix(), 10))
				if tt.mutate != nil {
					tt.mutate(headers)
				}

				got := classifyClaudeRateTestError(t, fast, headers, tt.body)
				if got < 4*time.Hour-2*time.Second || got > 4*time.Hour+30*time.Second {
					t.Fatalf("RetryAfter = %v, want ~4h conservative unified cooldown", got)
				}
			})
		}
	}
}