package util
import (
"context"
"errors"
"fmt"
"testing"
)
func assertClassifyError(t *testing.T, err error, wantStatus int, wantLevel ErrorLevel, wantRetry bool, reason string) {
t.Helper()
statusCode, errorLevel, shouldRetry := ClassifyError(err)
if statusCode != wantStatus {
t.Errorf("状态码错误: 期望 %d, 实际 %d (%s)", wantStatus, statusCode, reason)
}
if errorLevel != wantLevel {
t.Errorf("错误级别错误: 期望 %v, 实际 %v (%s)", wantLevel, errorLevel, reason)
}
if shouldRetry != wantRetry {
t.Errorf("重试标志错误: 期望 %v, 实际 %v (%s)", wantRetry, shouldRetry, reason)
}
}
func TestClassifyHTTPResponse(t *testing.T) {
tests := []struct {
name string
statusCode int
responseBody []byte
expected ErrorLevel
reason string
}{
// 401错误 - Key级场景（新设计：额度用尽先尝试其他Key）
{
name: "401_quota_exhausted_chinese",
statusCode: 401,
responseBody: []byte(`{"error":{"message":"该令牌额度已用尽"}}`),
expected: ErrorLevelKey,
reason: "额度用尽可能只是单个Key问题，应先尝试其他Key",
},
{
name: "401_insufficient_quota",
statusCode: 401,
responseBody: []byte(`{"error":"insufficient_quota"}`),
expected: ErrorLevelKey,
reason: "insufficient_quota可能只是单个Key问题，应先尝试其他Key",
},
{
name: "401_balance_insufficient",
statusCode: 401,
responseBody: []byte(`{"error":"balance insufficient"}`),
expected: ErrorLevelKey,
reason: "余额不足可能只是单个Key问题，应先尝试其他Key",
},
// 401错误 - 渠道级场景（仅限账户级不可逆错误）
{
name: "401_account_suspended",
statusCode: 401,
responseBody: []byte(`{"error":"account suspended"}`),
expected: ErrorLevelChannel,
reason: "账户暂停是账户级不可逆错误，应冷却整个渠道",
},
{
name: "401_account_disabled",
statusCode: 401,
responseBody: []byte(`{"error":"account disabled"}`),
expected: ErrorLevelChannel,
reason: "账户禁用是账户级不可逆错误，应冷却整个渠道",
},
// 401错误 - Key级场景
{
name: "401_invalid_authentication",
statusCode: 401,
responseBody: []byte(`{"error":"invalid_authentication"}`),
expected: ErrorLevelKey,
reason: "认证失败应该仅冷却当前Key",
},
{
name: "401_token_expired",
statusCode: 401,
responseBody: []byte(`{"error":"token expired"}`),
expected: ErrorLevelKey,
reason: "Token过期应该仅冷却当前Key（与account expired区分）",
},
{
name: "401_unauthorized",
statusCode: 401,
responseBody: []byte(`{"error":"unauthorized"}`),
expected: ErrorLevelKey,
reason: "未授权应该仅冷却当前Key",
},
{
name: "401_empty_body",
statusCode: 401,
responseBody: []byte{},
expected: ErrorLevelKey,
reason: "无响应体默认为Key级错误",
},
// 403错误 - Key级场景（新设计：额度/限额类错误先尝试其他Key）
{
name: "403_quota_exceeded_openai_style",
statusCode: 403,
responseBody: []byte(`{"error":{"type":"quota_exceeded","message":"Daily cost limit reached ($1)"},"details":{"dailyLimit":1,"currentUsage":1.09655195,"remaining":0}}`),
expected: ErrorLevelKey,
reason: "quota_exceeded可能只是单个Key问题，应先尝试其他Key",
},
{
name: "403_daily_limit_reached",
statusCode: 403,
responseBody: []byte(`{"error":"Daily cost limit reached ($10)"}`),
expected: ErrorLevelKey,
reason: "Daily limit可能只是单个Key问题，应先尝试其他Key",
},
{
name: "403_remaining_zero",
statusCode: 403,
responseBody: []byte(`{"details":{"remaining":0}}`),
expected: ErrorLevelKey,
reason: "remaining:0可能只是单个Key问题，应先尝试其他Key",
},
{
name: "403_quota_chinese",
statusCode: 403,
responseBody: []byte(`{"error":"余额不足，请充值"}`),
expected: ErrorLevelKey,
reason: "余额不足可能只是单个Key问题，应先尝试其他Key",
},
// 403错误 - 渠道级场景（仅限账户级不可逆错误）
{
name: "403_service_disabled",
statusCode: 403,
responseBody: []byte(`{"error":"service disabled"}`),
expected: ErrorLevelChannel,
reason: "服务禁用是账户级不可逆错误，应冷却整个渠道",
},
// 403错误 - Key级场景
{
name: "403_permission_denied",
statusCode: 403,
responseBody: []byte(`{"error":"permission denied"}`),
expected: ErrorLevelKey,
reason: "403 + permission denied应该仅冷却当前Key",
},
{
name: "403_forbidden",
statusCode: 403,
responseBody: []byte(`{"error":"forbidden"}`),
expected: ErrorLevelKey,
reason: "403 + forbidden应该仅冷却当前Key",
},
{
name: "403_empty_body",
statusCode: 403,
responseBody: []byte{},
expected: ErrorLevelKey,
reason: "403无响应体默认为Key级错误",
},
// 其他状态码（确保不影响现有逻辑）
{
name: "404_not_found",
statusCode: 404,
responseBody: []byte(`{"error":"not found"}`),
expected: ErrorLevelChannel,
reason: "404非model_not_found应返回渠道级错误以触发切换",
},
{
name: "500_internal_error",
statusCode: 500,
responseBody: []byte(`{"error":"internal server error"}`),
expected: ErrorLevelChannel,
reason: "500应该冷却渠道",
},
{
name: "429_rate_limit",
statusCode: 429,
responseBody: []byte(`{"error":"rate limit exceeded"}`),
expected: ErrorLevelKey,
reason: "429应该冷却Key",
},
// 边界情况
{
name: "401_case_insensitive",
statusCode: 401,
responseBody: []byte(`{"error":"Account SUSPENDED"}`),
expected: ErrorLevelChannel,
reason: "大小写不敏感匹配（account suspended）",
},
{
name: "401_mixed_case",
statusCode: 401,
responseBody: []byte(`{"error":"Account Disabled"}`),
expected: ErrorLevelChannel,
reason: "混合大小写应该正确识别（account disabled）",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := ClassifyHTTPResponseWithMeta(tt.statusCode, nil, tt.responseBody).Level
if result != tt.expected {
t.Errorf("%s\n 期望: %v\n 实际: %v\n 原因: %s\n 响应体: %s",
tt.name, tt.expected, result, tt.reason, string(tt.responseBody))
}
})
}
}
func TestClassifyHTTPStatus(t *testing.T) {
tests := []struct {
statusCode int
expected ErrorLevel
reason string
}{
{200, ErrorLevelNone, "2xx成功"},
{201, ErrorLevelNone, "2xx成功"},
{402, ErrorLevelKey, "402 应视为Key级（额度/余额/配额）"},
{401, ErrorLevelKey, "Key级错误（默认）"},
{403, ErrorLevelKey, "Key级错误"},
{429, ErrorLevelKey, "Key级限流"},
// 499 HTTP响应应触发渠道级重试
{499, ErrorLevelChannel, "499来自HTTP响应时，说明上游API返回，应重试其他渠道"},
// nginx 非标准状态码
{444, ErrorLevelChannel, "444 nginx No Response - 服务器主动关闭连接，渠道级错误"},
{500, ErrorLevelChannel, "渠道级错误"},
{502, ErrorLevelChannel, "渠道级错误"},
{503, ErrorLevelChannel, "渠道级错误"},
{504, ErrorLevelChannel, "渠道级错误"},
{520, ErrorLevelChannel, "520 Web Server Returned an Unknown Error - 渠道级错误"},
{521, ErrorLevelChannel, "521 Web Server Is Down - 渠道级错误"},
{524, ErrorLevelChannel, "524 A Timeout Occurred - 渠道级错误"},
// 兜底策略测试
{418, ErrorLevelKey, "418 未知4xx - 兜底策略应为Key级冷却"},
{451, ErrorLevelKey, "451 未知4xx - 兜底策略应为Key级冷却"},
{599, ErrorLevelChannel, "599 未知5xx - 兜底策略应为Channel级冷却"},
}
for _, tt := range tests {
t.Run(string(rune(tt.statusCode)), func(t *testing.T) {
result := ClassifyHTTPStatus(tt.statusCode)
if result != tt.expected {
t.Errorf("状态码 %d: 期望 %v, 实际 %v (%s)", tt.statusCode, tt.expected, result, tt.reason)
}
})
}
}
// 测试context.Canceled与HTTP 499的区分
func TestClassifyError_ContextCanceled(t *testing.T) {
tests := []struct {
name string
err error
expectedStatus int
expectedLevel ErrorLevel
expectedRetry bool
reason string
}{
{
name: "context_canceled_from_client",
err: context.Canceled,
expectedStatus: 499,
expectedLevel: ErrorLevelClient,
expectedRetry: false,
reason: "下游客户端取消请求（context.Canceled）应返回499+ErrorLevelClient，不重试",
},
{
name: "context_deadline_exceeded",
err: context.DeadlineExceeded,
expectedStatus: 504,
expectedLevel: ErrorLevelChannel,
expectedRetry: true,
reason: "上游超时（context.DeadlineExceeded）应返回504+ErrorLevelChannel，可重试其他渠道",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
assertClassifyError(t, tt.err, tt.expectedStatus, tt.expectedLevel, tt.expectedRetry, tt.reason)
})
}
}
// 测试空响应错误分类
func TestClassifyError_EmptyResponse(t *testing.T) {
tests := []struct {
name string
err error
expectedStatus int
expectedLevel ErrorLevel
expectedRetry bool
reason string
}{
{
name: "empty_response_200_with_content_length_0",
err: errors.New("upstream returned empty response (200 OK with Content-Length: 0)"),
expectedStatus: 502,
expectedLevel: ErrorLevelChannel,
expectedRetry: true,
reason: "200状态码但Content-Length=0应视为上游故障，触发渠道级重试",
},
{
name: "empty_response_uppercase",
err: errors.New("Upstream Returned Empty Response (200 OK with Content-Length: 0)"),
expectedStatus: 502,
expectedLevel: ErrorLevelChannel,
expectedRetry: true,
reason: "大小写不敏感匹配",
},
{
name: "empty_response_sentinel_without_content_length",
err: fmt.Errorf("response probe failed: %w", ErrUpstreamEmptyResponse),
expectedStatus: 502,
expectedLevel: ErrorLevelChannel,
expectedRetry: true,
reason: "无Content-Length的200空体也应视为上游故障，不能依赖错误文案",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
assertClassifyError(t, tt.err, tt.expectedStatus, tt.expectedLevel, tt.expectedRetry, tt.reason)
})
}
}
// 测试HTTP/2流错误分类
func TestClassifyError_HTTP2StreamErrors(t *testing.T) {
tests := []struct {
name string
err error
expectedStatus int
expectedLevel ErrorLevel
expectedRetry bool
reason string
}{
{
name: "http2_response_body_closed",
err: fmt.Errorf("http2: response body closed"),
expectedStatus: 502, // Bad Gateway
expectedLevel: ErrorLevelChannel,
expectedRetry: true,
reason: "上游服务器主动关闭HTTP/2流，应触发渠道级重试",
},
{
name: "http2_stream_error_internal",
err: fmt.Errorf("stream error: stream ID 7; INTERNAL_ERROR"),
expectedStatus: 502, // Bad Gateway
expectedLevel: ErrorLevelChannel,
expectedRetry: true,
reason: "HTTP/2 RST_STREAM INTERNAL_ERROR，上游服务异常",
},
{
name: "http2_stream_error_protocol",
err: fmt.Errorf("stream error: stream ID 3; PROTOCOL_ERROR"),
expectedStatus: 502, // Bad Gateway
expectedLevel: ErrorLevelChannel,
expectedRetry: true,
reason: "HTTP/2协议错误，应切换渠道重试",
},
{
name: "http2_error_wrapped",
err: fmt.Errorf("failed to read response: http2: response body closed"),
expectedStatus: 502, // Bad Gateway
expectedLevel: ErrorLevelChannel,
expectedRetry: true,
reason: "包装后的HTTP/2错误也应正确识别",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
assertClassifyError(t, tt.err, tt.expectedStatus, tt.expectedLevel, tt.expectedRetry, tt.reason)
})
}
}
func TestClassifyError_ConnectionResetAndBrokenPipe(t *testing.T) {
tests := []struct {
name string
err error
expectedStatus int
expectedLevel ErrorLevel
expectedRetry bool
reason string
}{
{
name: "broken_pipe_client_closed",
err: errors.New("write: broken pipe"),
expectedStatus: 499,
expectedLevel: ErrorLevelClient,
expectedRetry: false,
reason: "broken pipe 基本是客户端断开，不应重试",
},
{
name: "connection_reset_by_peer_upstream",
err: errors.New("read: connection reset by peer"),
expectedStatus: 502,
expectedLevel: ErrorLevelChannel,
expectedRetry: true,
reason: "connection reset by peer 通常是上游断开，应按 502 进入健康度统计并允许切换渠道重试",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
assertClassifyError(t, tt.err, tt.expectedStatus, tt.expectedLevel, tt.expectedRetry, tt.reason)
})
}
}
// 测试429错误的智能分类
func TestClassifyRateLimitError(t *testing.T) {
tests := []struct {
name string
headers map[string][]string
responseBody []byte
expected ErrorLevel
reason string
}{
// Retry-After头测试
{
name: "retry_after_120_seconds",
headers: map[string][]string{
"Retry-After": {"120"},
},
responseBody: []byte(`{"error":"rate limit exceeded"}`),
expected: ErrorLevelChannel,
reason: "Retry-After > 60秒表示账户级或IP级限流，应冷却渠道",
},
{
name: "retry_after_30_seconds",
headers: map[string][]string{
"Retry-After": {"30"},
},
responseBody: []byte(`{"error":"rate limit exceeded"}`),
expected: ErrorLevelKey,
reason: "Retry-After ≤ 60秒表示Key级限流，应冷却Key",
},
{
name: "retry_after_60_seconds_boundary",
headers: map[string][]string{
"Retry-After": {"60"},
},
responseBody: []byte(`{"error":"rate limit exceeded"}`),
expected: ErrorLevelKey,
reason: "Retry-After = 60秒边界值，保守策略为Key级",
},
{
name: "retry_after_http_date",
headers: map[string][]string{
"Retry-After": {"Wed, 29 Oct 2025 12:00:00 GMT"},
},
responseBody: []byte(`{"error":"rate limit exceeded"}`),
expected: ErrorLevelChannel,
reason: "HTTP日期格式通常表示长时间限流，应冷却渠道",
},
{
name: "retry_after_invalid_format",
headers: map[string][]string{
"Retry-After": {"invalid"},
},
responseBody: []byte(`{"error":"rate limit exceeded"}`),
expected: ErrorLevelKey,
reason: "无效的Retry-After格式应默认为Key级",
},
// X-RateLimit-Scope头测试
{
name: "scope_global",
headers: map[string][]string{
"X-Ratelimit-Scope": {"global"},
},
responseBody: []byte(`{"error":"rate limit exceeded"}`),
expected: ErrorLevelChannel,
reason: "global scope表示全局限流，应冷却渠道",
},
{
name: "scope_ip",
headers: map[string][]string{
"X-Ratelimit-Scope": {"ip"},
},
responseBody: []byte(`{"error":"rate limit exceeded"}`),
expected: ErrorLevelChannel,
reason: "IP scope表示IP级限流，应冷却渠道",
},
{
name: "scope_account",
headers: map[string][]string{
"X-Ratelimit-Scope": {"account"},
},
responseBody: []byte(`{"error":"rate limit exceeded"}`),
expected: ErrorLevelChannel,
reason: "account scope表示账户级限流，应冷却渠道",
},
{
name: "scope_user",
headers: map[string][]string{
"X-Ratelimit-Scope": {"user"},
},
responseBody: []byte(`{"error":"rate limit exceeded"}`),
expected: ErrorLevelKey,
reason: "user scope（非global/ip/account）应默认为Key级",
},
{
name: "scope_case_insensitive",
headers: map[string][]string{
"X-Ratelimit-Scope": {"GLOBAL"},
},
responseBody: []byte(`{"error":"rate limit exceeded"}`),
expected: ErrorLevelChannel,
reason: "scope匹配应不区分大小写",
},
// 响应体错误描述测试
{
name: "body_ip_rate_limit",
headers: map[string][]string{},
responseBody: []byte(`{
"error": {
"message": "IP rate limit exceeded",
"type": "rate_limit_error"
}
}`),
expected: ErrorLevelChannel,
reason: "响应体包含'ip rate limit'应冷却渠道",
},
{
name: "body_account_rate_limit",
headers: map[string][]string{},
responseBody: []byte(`{
"error": {
"message": "Account rate limit exceeded for organization"
}
}`),
expected: ErrorLevelChannel,
reason: "响应体包含'account rate limit'应冷却渠道",
},
{
name: "body_global_rate_limit",
headers: map[string][]string{},
responseBody: []byte(`{
"error": "Global rate limit has been exceeded"
}`),
expected: ErrorLevelChannel,
reason: "响应体包含'global rate limit'应冷却渠道",
},
{
name: "body_organization_limit",
headers: map[string][]string{},
responseBody: []byte(`{
"error": "Organization limit reached"
}`),
expected: ErrorLevelChannel,
reason: "响应体包含'organization limit'应冷却渠道",
},
{
name: "body_case_insensitive",
headers: map[string][]string{},
responseBody: []byte(`{
"error": "IP Rate Limit Exceeded"
}`),
expected: ErrorLevelChannel,
reason: "响应体匹配应不区分大小写",
},
// 默认Key级限流测试
{
name: "default_key_level_no_special_indicators",
headers: map[string][]string{},
responseBody: []byte(`{
"error": "Too many requests"
}`),
expected: ErrorLevelKey,
reason: "无特殊指示器时应默认为Key级",
},
{
name: "nil_headers",
headers: nil,
responseBody: []byte(`{"error":"rate limit"}`),
expected: ErrorLevelKey,
reason: "nil headers应默认为Key级",
},
{
name: "empty_headers",
headers: map[string][]string{},
responseBody: []byte(`{"error":"rate limit"}`),
expected: ErrorLevelKey,
reason: "空headers应默认为Key级",
},
{
name: "empty_response_body",
headers: map[string][]string{},
responseBody: []byte{},
expected: ErrorLevelKey,
reason: "空响应体应默认为Key级",
},
{
name: "nil_response_body",
headers: map[string][]string{},
responseBody: nil,
expected: ErrorLevelKey,
reason: "nil响应体应默认为Key级",
},
// 组合场景测试
{
name: "combined_retry_after_and_scope",
headers: map[string][]string{
"Retry-After": {"30"}, // Key级指示器
"X-Ratelimit-Scope": {"ip"}, // 渠道级指示器
},
responseBody: []byte(`{"error":"rate limit"}`),
expected: ErrorLevelChannel,
reason: "Retry-After检查优先于Scope，但>60秒判断优先",
},
{
name: "combined_scope_and_body",
headers: map[string][]string{
"X-Ratelimit-Scope": {"user"}, // Key级指示器
},
responseBody: []byte(`{"error":"IP rate limit exceeded"}`), // 渠道级指示器
expected: ErrorLevelChannel,
reason: "响应体中的渠道级指示器应被识别",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := ClassifyHTTPResponseWithMeta(429, tt.headers, tt.responseBody).Level
if result != tt.expected {
t.Errorf("%s\n 期望: %v\n 实际: %v\n 原因: %s",
tt.name, tt.expected, result, tt.reason)
}
})
}
}
// TestClassifySSEError 测试SSE error事件分类
func TestClassifySSEError(t *testing.T) {
tests := []struct {
name string
responseBody []byte
expected ErrorLevel
reason string
}{
{
name: "api_error_500",
responseBody: []byte(`{"type":"error","error":{"type":"api_error","message":"上游API返回错误: 500"}}`),
expected: ErrorLevelChannel,
reason: "api_error表示上游服务错误，应触发渠道级冷却",
},
{
name: "overloaded_error",
responseBody: []byte(`{"type":"error","error":{"type":"overloaded_error","message":"服务过载"}}`),
expected: ErrorLevelChannel,
reason: "overloaded_error表示上游过载，应触发渠道级冷却",
},
{
name: "service_unavailable_error_server_is_overloaded",
responseBody: []byte(`{"type":"error","error":{"type":"service_unavailable_error","code":"server_is_overloaded","message":"Our servers are currently overloaded. Please try again later.","param":null},"sequence_number":2}`),
expected: ErrorLevelChannel,
reason: "service_unavailable_error/server_is_overloaded 表示上游服务过载，应触发渠道级冷却",
},
{
name: "rate_limit_error",
responseBody: []byte(`{"type":"error","error":{"type":"rate_limit_error","message":"请求过于频繁"}}`),
expected: ErrorLevelKey,
reason: "rate_limit_error可能只是单个Key限流，应触发Key级冷却",
},
{
name: "authentication_error",
responseBody: []byte(`{"type":"error","error":{"type":"authentication_error","message":"认证失败"}}`),
expected: ErrorLevelKey,
reason: "authentication_error是Key级问题，应触发Key级冷却",
},
{
name: "invalid_request_error",
responseBody: []byte(`{"type":"error","error":{"type":"invalid_request_error","message":"请求无效"}}`),
expected: ErrorLevelKey,
reason: "invalid_request_error是Key级问题，应触发Key级冷却",
},
{
name: "1308_error",
responseBody: []byte(`{"type":"error","error":{"type":"1308","message":"已达到使用上限"}}`),
expected: ErrorLevelKey,
reason: "1308错误是Key配额问题，应触发Key级冷却",
},
{
name: "1308_error_with_code_field",
responseBody: []byte(`{"error":{"code":"1308","message":"已达到 5 小时的使用上限。您的限额将在 2025-12-21 15:00:05 重置。"},"request_id":"202512211335142b05cc4f9bbb4e6c"}`),
expected: ErrorLevelKey,
reason: "使用code字段的1308错误（非Anthropic格式）应触发Key级冷却",
},
{
name: "1305_overloaded",
responseBody: []byte(`{"error":{"code":"1305","message":"The service may be temporarily overloaded"},"request_id":"..."}`),
expected: ErrorLevelChannel,
reason: "1305错误表示上游过载，应触发渠道级冷却",
},
{
name: "1310_limit_exhausted",
responseBody: []byte(`{"error":{"code":"1310","message":"Weekly/Monthly Limit Exhausted. Your limit will reset at 2026-04-20 15:24:20"},"request_id":"..."}`),
expected: ErrorLevelKey,
reason: "1310错误是Key配额问题，应触发Key级冷却",
},
{
name: "unknown_error_type",
responseBody: []byte(`{"type":"error","error":{"type":"unknown_type","message":"未知错误"}}`),
expected: ErrorLevelKey,
reason: "未知错误类型应保守处理为Key级",
},
{
name: "empty_body",
responseBody: []byte{},
expected: ErrorLevelKey,
reason: "空响应体应保守处理为Key级",
},
{
name: "invalid_json",
responseBody: []byte(`not valid json`),
expected: ErrorLevelKey,
reason: "无效JSON应保守处理为Key级",
},
{
name: "nil_body",
responseBody: nil,
expected: ErrorLevelKey,
reason: "nil响应体应保守处理为Key级",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// 使用 ClassifyHTTPResponseWithMeta 测试 597 状态码
result := ClassifyHTTPResponseWithMeta(StatusSSEError, nil, tt.responseBody).Level
if result != tt.expected {
t.Errorf("%s\n 期望: %v\n 实际: %v\n 原因: %s",
tt.name, tt.expected, result, tt.reason)
}
})
}
}
func TestClassify400Error(t *testing.T) {
tests := []struct {
name string
responseBody []byte
expected ErrorLevel
reason string
}{
{
name: "empty_body",
responseBody: []byte{},
expected: ErrorLevelChannel,
reason: "空响应体应判定为上游异常",
},
{
name: "nil_body",
responseBody: nil,
expected: ErrorLevelChannel,
reason: "nil响应体应判定为上游异常",
},
{
name: "invalid_api_key",
responseBody: []byte(`{"error": {"message": "Invalid API Key provided"}}`),
expected: ErrorLevelKey,
reason: "包含 invalid_api_key 特征应判定为 Key 级错误",
},
{
name: "api_key_error",
responseBody: []byte(`{"error": {"message": "The API key you provided is malformed"}}`),
expected: ErrorLevelKey,
reason: "包含 api key 特征应判定为 Key 级错误",
},
{
name: "bad_request_params",
responseBody: []byte(`{"error": {"message": "Missing required parameter: 'model'"}}`),
expected: ErrorLevelChannel,
reason: "代理场景下400默认视为上游异常",
},
{
name: "invalid_json_format",
responseBody: []byte(`{"error": {"message": "Invalid JSON format in request body"}}`),
expected: ErrorLevelChannel,
reason: "代理场景下400默认视为上游异常",
},
{
name: "validation_error",
responseBody: []byte(`{"error": {"message": "Validation failed: max_tokens must be positive"}}`),
expected: ErrorLevelChannel,
reason: "代理场景下400默认视为上游异常",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := classify400Error(tt.responseBody)
if result != tt.expected {
t.Errorf("%s\n 期望: %v\n 实际: %v\n 原因: %s\n 响应体: %s",
tt.name, tt.expected, result, tt.reason, string(tt.responseBody))
}
})
}
}
func TestClassify404Error(t *testing.T) {
tests := []struct {
name string
responseBody []byte
expected ErrorLevel
reason string
}{
{
name: "empty_body",
responseBody: []byte{},
expected: ErrorLevelChannel,
reason: "空响应体应判定为渠道配置错误（路径不存在）",
},
{
name: "nil_body",
responseBody: nil,
expected: ErrorLevelChannel,
reason: "nil响应体应判定为渠道配置错误（路径不存在）",
},
{
name: "model_not_found",
responseBody: []byte(`{"error": {"message": "The model 'gpt-5' could not be found", "type": "model_not_found"}}`),
expected: ErrorLevelClient,
reason: "模型不存在应判定为客户端级错误",
},
{
name: "resource_not_exist",
responseBody: []byte(`{"error": {"message": "The requested resource does not exist"}}`),
expected: ErrorLevelClient,
reason: "资源不存在应判定为客户端级错误",
},
{
name: "html_error_page",
responseBody: []byte(`
404 Not Found
404 Not Found
`),
expected: ErrorLevelChannel,
reason: "HTML错误页面应判定为渠道级错误（BaseURL配置错误）",
},
{
name: "html_lowercase",
responseBody: []byte(`Not Found404`),
expected: ErrorLevelChannel,
reason: "HTML错误页面（小写）应判定为渠道级错误",
},
{
name: "endpoint_not_found",
responseBody: []byte(`{"error": {"message": "Endpoint /v1/completions not found"}}`),
expected: ErrorLevelChannel,
reason: "端点不存在应判定为渠道级错误（标准路径返回404更可能是渠道配置问题）",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := classify404Error(tt.responseBody)
if result != tt.expected {
t.Errorf("%s\n 期望: %v\n 实际: %v\n 原因: %s\n 响应体: %s",
tt.name, tt.expected, result, tt.reason, string(tt.responseBody))
}
})
}
}
func TestGetStatusCodeMeta(t *testing.T) {
t.Parallel()
tests := []struct {
status int
wantLevel ErrorLevel
description string
}{
// Key级错误
{401, ErrorLevelKey, "401 -> Key级"},
{402, ErrorLevelKey, "402 -> Key级"},
{403, ErrorLevelKey, "403 -> Key级"},
{429, ErrorLevelKey, "429 -> Key级"},
// 渠道级错误
{499, ErrorLevelChannel, "499 -> 渠道级"},
{500, ErrorLevelChannel, "500 -> 渠道级"},
{502, ErrorLevelChannel, "502 -> 渠道级"},
{503, ErrorLevelChannel, "503 -> 渠道级"},
{504, ErrorLevelChannel, "504 -> 渠道级"},
{408, ErrorLevelClient, "408 -> 客户端级 (RFC7231: 客户端发送请求慢)"},
{405, ErrorLevelChannel, "405 -> 渠道级 (上游endpoint/方法不支持)"},
// 自定义状态码
{StatusQuotaExceeded, ErrorLevelKey, "596 -> Key级"},
{StatusSSEError, ErrorLevelKey, "597 -> Key级"},
{StatusFirstByteTimeout, ErrorLevelChannel, "598 -> 渠道级"},
{StatusStreamIncomplete, ErrorLevelChannel, "599 -> 渠道级"},
// 客户端错误
{406, ErrorLevelClient, "406 -> 客户端级"},
{413, ErrorLevelClient, "413 -> 客户端级"},
// 默认行为
{599, ErrorLevelChannel, "599 -> 渠道级(自定义)"},
{418, ErrorLevelKey, "418 -> Key级(兜底策略:未知4xx)"},
{511, ErrorLevelChannel, "511 -> 渠道级(默认5xx)"},
}
for _, tt := range tests {
t.Run(tt.description, func(t *testing.T) {
meta := GetStatusCodeMeta(tt.status)
if meta.Level != tt.wantLevel {
t.Errorf("Level: got %v, want %v", meta.Level, tt.wantLevel)
}
})
}
}
func TestClientStatusFor(t *testing.T) {
t.Parallel()
tests := []struct {
status int
expected int
desc string
}{
{-1, 502, "负值 -> 502"},
{0, 502, "零值 -> 502"},
{StatusQuotaExceeded, 429, "596 -> 429"},
{StatusSSEError, 502, "597 -> 502"},
{StatusFirstByteTimeout, 504, "598 -> 504"},
{StatusStreamIncomplete, 502, "599 -> 502"},
{429, 429, "429 -> 透传"},
{401, 401, "401 -> 401 (透明代理)"},
{405, 405, "405 -> 405 (透明代理)"},
{404, 404, "404 -> 404 (透明代理)"},
{499, 499, "499 -> 499（语义由上层决定）"},
{502, 502, "502 -> 502"},
}
for _, tt := range tests {
t.Run(tt.desc, func(t *testing.T) {
if got := ClientStatusFor(tt.status); got != tt.expected {
t.Fatalf("ClientStatusFor(%d)=%d, expected %d", tt.status, got, tt.expected)
}
})
}
}
// IsRetryableStatus 已移除：重试决策不应依赖静态状态码表，而应依赖 errorLevel/shouldRetry 等语义信息。