mirror of
https://github.com/Wei-Shaw/sub2api.git
synced 2026-10-15 23:22:59 +08:00
shaw
d19265ddb2
composite 分组中 openai OAuth 账号与 deepseek API Key 账号同时显式映射同一 gpt 模型时，模型归属判为歧义、路由层不解析平台，请求落到默认 Anthropic GatewayHandler；handler 再按模型名前缀猜回 openai 并选中 OpenAI OAuth 账号， ChatGPT token 被发往 api.anthropic.com，上游 401 "Invalid bearer token" 经 failover 逐号打成临时不可调度，单请求即可扫空号池。 - 归属记录声明方是否含 OpenAI 网关族 OAuth / setup-token；当模型名兜底也 落在 OpenAI 网关族时判为配置错误，路由中间件与 WS 入口直接 400 拒绝并 提示配置显式路由。纯 API Key 歧义及 Anthropic/Antigravity/Gemini OAuth 歧义保持原行为。 - 模型归属改按配置计算（ListModelAvailabilityCandidates），不再随限流 / 临时不可调度在「唯一归属」与「歧义」之间翻转。 - Anthropic 请求构建前校验凭据：非 Anthropic 网关族的 OAuth 凭据不出站， 返回仅换号、不处罚账号的 failover；count_tokens 返回 404 不支持。 API Key 不受限（上游可能兼容多种协议格式）。
261 lines
11 KiB
Go
261 lines
11 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
|
|
"github.com/Wei-Shaw/sub2api/internal/pkg/ctxkey"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
type compositeOwnershipAccountRepo struct {
|
|
AccountRepository
|
|
accounts []Account
|
|
}
|
|
|
|
func (r *compositeOwnershipAccountRepo) ListModelAvailabilityCandidates(context.Context, *int64, []string, bool) ([]Account, error) {
|
|
return r.accounts, nil
|
|
}
|
|
|
|
// Scenario: 唯一平台的精确别名可路由
|
|
func TestResolveCompositeModelOwnershipKeepsProviderAccountsIsolated(t *testing.T) {
|
|
groupID := int64(7)
|
|
repo := &compositeOwnershipAccountRepo{
|
|
accounts: []Account{
|
|
{
|
|
ID: 1,
|
|
Platform: PlatformOpenAI,
|
|
Credentials: map[string]any{
|
|
"model_mapping": map[string]any{"gpt-public": "gpt-5"},
|
|
},
|
|
},
|
|
{
|
|
ID: 2,
|
|
Platform: PlatformDeepseek,
|
|
Credentials: map[string]any{
|
|
"model_mapping": map[string]any{"reasoning-alias": "deepseek-v4-pro"},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
svc := &GatewayService{accountRepo: repo}
|
|
|
|
deepSeekOwnership, err := svc.resolveCompositeModelOwnership(context.Background(), groupID, "reasoning-alias")
|
|
require.NoError(t, err)
|
|
require.Equal(t, CompositeModelOwnership{TargetPlatform: PlatformDeepseek, Matched: true}, deepSeekOwnership)
|
|
|
|
openAIOwnership, err := svc.resolveCompositeModelOwnership(context.Background(), groupID, "gpt-public")
|
|
require.NoError(t, err)
|
|
require.Equal(t, CompositeModelOwnership{TargetPlatform: PlatformOpenAI, Matched: true}, openAIOwnership)
|
|
}
|
|
|
|
// Scenario: 通配符和空映射不声明所有权
|
|
func TestResolveCompositeModelOwnershipRequiresNonEmptyExactMappings(t *testing.T) {
|
|
groupID := int64(7)
|
|
repo := &compositeOwnershipAccountRepo{
|
|
accounts: []Account{
|
|
{
|
|
ID: 1,
|
|
Platform: PlatformOpenAI,
|
|
Credentials: map[string]any{
|
|
"model_mapping": map[string]any{"*": "gpt-5", "gpt-*": "gpt-5", "empty-alias": ""},
|
|
},
|
|
},
|
|
{
|
|
ID: 2,
|
|
Platform: PlatformGrok,
|
|
Credentials: map[string]any{
|
|
"model_mapping": map[string]any{"grok-public": "grok-4"},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
svc := &GatewayService{accountRepo: repo}
|
|
|
|
for _, model := range []string{"gpt-5", "empty-alias", "unknown-alias"} {
|
|
ownership, err := svc.resolveCompositeModelOwnership(context.Background(), groupID, model)
|
|
require.NoError(t, err)
|
|
require.Equal(t, CompositeModelOwnership{}, ownership, "model=%s", model)
|
|
}
|
|
|
|
ownership, err := svc.resolveCompositeModelOwnership(context.Background(), groupID, "grok-public")
|
|
require.NoError(t, err)
|
|
require.Equal(t, CompositeModelOwnership{TargetPlatform: PlatformGrok, Matched: true}, ownership)
|
|
}
|
|
|
|
func TestResolveCompositeModelOwnershipAllowsSamePlatformAndRejectsCrossPlatformAliases(t *testing.T) {
|
|
groupID := int64(7)
|
|
repo := &compositeOwnershipAccountRepo{
|
|
accounts: []Account{
|
|
{ID: 1, Platform: PlatformOpenAI, Credentials: map[string]any{"model_mapping": map[string]any{"shared-openai": "gpt-5", "ambiguous": "gpt-5"}}},
|
|
{ID: 2, Platform: PlatformOpenAI, Credentials: map[string]any{"model_mapping": map[string]any{"shared-openai": "gpt-5.1"}}},
|
|
{ID: 3, Platform: PlatformDeepseek, Credentials: map[string]any{"model_mapping": map[string]any{"ambiguous": "deepseek-v4-pro"}}},
|
|
},
|
|
}
|
|
svc := &GatewayService{accountRepo: repo}
|
|
|
|
samePlatform, err := svc.resolveCompositeModelOwnership(context.Background(), groupID, "shared-openai")
|
|
require.NoError(t, err)
|
|
require.Equal(t, CompositeModelOwnership{TargetPlatform: PlatformOpenAI, Matched: true}, samePlatform)
|
|
|
|
ambiguous, err := svc.resolveCompositeModelOwnership(context.Background(), groupID, "ambiguous")
|
|
require.NoError(t, err)
|
|
require.Equal(t, CompositeModelOwnership{Ambiguous: true}, ambiguous)
|
|
}
|
|
|
|
// Scenario: 只有 OpenAI 网关族的 OAuth 声明方会被标记（API Key 上游可能兼容多协议，
|
|
// Anthropic / Antigravity 的 OAuth 在默认 Anthropic handler 中可正常转发）
|
|
func TestResolveCompositeModelOwnershipFlagsOpenAIGatewayOAuthClaimants(t *testing.T) {
|
|
groupID := int64(7)
|
|
repo := &compositeOwnershipAccountRepo{
|
|
accounts: []Account{
|
|
{ID: 1, Platform: PlatformOpenAI, Type: AccountTypeOAuth, Credentials: map[string]any{"model_mapping": map[string]any{"gpt-6-astra": "gpt-6-astra"}}},
|
|
{ID: 2, Platform: PlatformDeepseek, Type: AccountTypeAPIKey, Credentials: map[string]any{"model_mapping": map[string]any{"gpt-6-astra": "deepseek-v4-pro", "apikey-only": "deepseek-v4-pro"}}},
|
|
{ID: 3, Platform: PlatformOpenAI, Type: AccountTypeAPIKey, Credentials: map[string]any{"model_mapping": map[string]any{"apikey-only": "gpt-5"}}},
|
|
// Antigravity 账号创建时会把默认映射（含 claude-*）写入 model_mapping。
|
|
{ID: 4, Platform: PlatformAntigravity, Type: AccountTypeOAuth, Credentials: map[string]any{"model_mapping": map[string]any{"claude-opus-4-8": "claude-opus-4-8"}}},
|
|
{ID: 5, Platform: PlatformAnthropic, Type: AccountTypeSetupToken, Credentials: map[string]any{"model_mapping": map[string]any{"claude-opus-4-8": "claude-opus-4-8"}}},
|
|
},
|
|
}
|
|
svc := &GatewayService{accountRepo: repo}
|
|
|
|
withOAuth, err := svc.resolveCompositeModelOwnership(context.Background(), groupID, "gpt-6-astra")
|
|
require.NoError(t, err)
|
|
require.Equal(t, CompositeModelOwnership{Ambiguous: true, OpenAIGatewayOAuthClaimed: true}, withOAuth)
|
|
|
|
apiKeyOnly, err := svc.resolveCompositeModelOwnership(context.Background(), groupID, "apikey-only")
|
|
require.NoError(t, err)
|
|
require.Equal(t, CompositeModelOwnership{Ambiguous: true}, apiKeyOnly)
|
|
|
|
anthropicFamily, err := svc.resolveCompositeModelOwnership(context.Background(), groupID, "claude-opus-4-8")
|
|
require.NoError(t, err)
|
|
require.Equal(t, CompositeModelOwnership{Ambiguous: true}, anthropicFamily)
|
|
}
|
|
|
|
func TestNewGatewayServiceWiresCompositeModelOwnershipResolver(t *testing.T) {
|
|
groupID := int64(7)
|
|
repo := &compositeOwnershipAccountRepo{
|
|
accounts: []Account{{
|
|
ID: 1,
|
|
Platform: PlatformDeepseek,
|
|
Credentials: map[string]any{"model_mapping": map[string]any{"reasoning-alias": "deepseek-v4-pro"}},
|
|
}},
|
|
}
|
|
resolver := NewCompositeRouteResolver(nil)
|
|
svc := NewGatewayService(
|
|
repo,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
resolver,
|
|
nil,
|
|
nil,
|
|
)
|
|
require.Same(t, resolver, svc.compositeResolver)
|
|
|
|
decision, err := resolver.Resolve(context.Background(), groupID, "reasoning-alias", CompositeRouteEndpointResponses)
|
|
require.NoError(t, err)
|
|
require.True(t, decision.Matched)
|
|
require.Equal(t, CompositeRouteSourceAccount, decision.Source)
|
|
require.Equal(t, PlatformDeepseek, decision.TargetPlatform)
|
|
}
|
|
|
|
func TestDetectModelPlatform(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
model string
|
|
platform string
|
|
ok bool
|
|
}{
|
|
{name: "claude", model: "claude-sonnet-4-5", platform: PlatformAnthropic, ok: true},
|
|
{name: "anthropic prefix", model: "anthropic/claude-opus-4-5", platform: PlatformAnthropic, ok: true},
|
|
{name: "gpt", model: "gpt-5.1", platform: PlatformOpenAI, ok: true},
|
|
{name: "o series", model: "o3-mini", platform: PlatformOpenAI, ok: true},
|
|
{name: "embedding", model: "text-embedding-3-large", platform: PlatformOpenAI, ok: true},
|
|
{name: "gemini", model: "gemini-3-pro", platform: PlatformGemini, ok: true},
|
|
{name: "gemini models prefix", model: "models/gemini-2.5-flash", platform: PlatformGemini, ok: true},
|
|
{name: "learnlm", model: "learnlm-2.0-flash-experimental", platform: PlatformGemini, ok: true},
|
|
{name: "grok", model: "grok-4", platform: PlatformGrok, ok: true},
|
|
{name: "xai prefix", model: "xai/grok-4", platform: PlatformGrok, ok: true},
|
|
{name: "kimi", model: "kimi-k2-thinking", platform: PlatformKimi, ok: true},
|
|
{name: "kimi code bare k3", model: "K3", platform: PlatformKimi, ok: true},
|
|
{name: "kimi code bare k3 256k", model: "k3-256k", platform: PlatformKimi, ok: true},
|
|
{name: "kimi code provider prefix", model: "kimi-code/k3", platform: PlatformKimi, ok: true},
|
|
{name: "moonshot prefix", model: "moonshot/moonshot-v1-32k", platform: PlatformKimi, ok: true},
|
|
{name: "zhipu", model: "glm-5.2", platform: PlatformZhipu, ok: true},
|
|
{name: "deepseek", model: "deepseek-v4-pro", platform: PlatformDeepseek, ok: true},
|
|
{name: "minimax", model: "MiniMax-M3", platform: PlatformMiniMax, ok: true},
|
|
{name: "minimax prefix", model: "minimax/MiniMax-M2.5", platform: PlatformMiniMax, ok: true},
|
|
{name: "abab legacy", model: "abab6.5-chat", platform: PlatformMiniMax, ok: true},
|
|
{name: "abab7 legacy", model: "abab7-chat-preview", platform: PlatformMiniMax, ok: true},
|
|
{name: "jev", model: "jev-latest", platform: PlatformTypeSafe, ok: true},
|
|
{name: "typesafe prefix", model: "typesafe/jev-latest", platform: PlatformTypeSafe, ok: true},
|
|
{name: "abab unrelated namespace", model: "abab-other", ok: false},
|
|
{name: "unknown k3 alias", model: "k3-preview", ok: false},
|
|
{name: "unknown", model: "llama-4-maverick", ok: false},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
platform, ok := DetectModelPlatform(tt.model)
|
|
require.Equal(t, tt.ok, ok)
|
|
require.Equal(t, tt.platform, platform)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestQuotaPlatformCompositeUsesResolvedOrForceOnly(t *testing.T) {
|
|
apiKey := &APIKey{Group: &Group{Platform: PlatformComposite}}
|
|
|
|
require.Equal(t, "", QuotaPlatform(context.Background(), apiKey))
|
|
require.Equal(t, PlatformGemini, QuotaPlatform(WithResolvedTargetPlatform(context.Background(), PlatformGemini), apiKey))
|
|
require.Equal(t, PlatformAntigravity, QuotaPlatform(context.WithValue(context.Background(), ctxkey.ForcePlatform, PlatformAntigravity), apiKey))
|
|
|
|
ctx := WithResolvedTargetPlatform(context.Background(), PlatformAnthropic)
|
|
ctx = context.WithValue(ctx, ctxkey.ForcePlatform, PlatformAntigravity)
|
|
require.Equal(t, PlatformAntigravity, QuotaPlatform(ctx, apiKey))
|
|
}
|
|
|
|
func TestCompositeGroupSchedulerHasAllCanonicalPlatformBuckets(t *testing.T) {
|
|
seen := make(map[string]struct{})
|
|
for _, bucket := range schedulerCanonicalBuckets(99) {
|
|
seen[bucket.Platform] = struct{}{}
|
|
}
|
|
platforms := make([]string, 0, len(seen))
|
|
for platform := range seen {
|
|
platforms = append(platforms, platform)
|
|
}
|
|
require.ElementsMatch(t,
|
|
[]string{PlatformAnthropic, PlatformGemini, PlatformOpenAI, PlatformAntigravity, PlatformGrok, PlatformKimi, PlatformZhipu, PlatformDeepseek, PlatformMiniMax, PlatformOpenCodeGo, PlatformTypeSafe, PlatformCommandCode, PlatformCline},
|
|
platforms,
|
|
)
|
|
}
|
|
|
|
func TestCompositeConcretePlatformsIncludeCNProviders(t *testing.T) {
|
|
for _, platform := range []string{PlatformKimi, PlatformZhipu, PlatformDeepseek, PlatformMiniMax, PlatformOpenCodeGo, PlatformTypeSafe, PlatformCommandCode, PlatformCline} {
|
|
require.True(t, isConcreteRequestPlatform(platform))
|
|
require.True(t, canCopyAccountsFromGroupPlatform(PlatformComposite, platform))
|
|
}
|
|
}
|