Files
sub2api/backend/internal/service/gateway_affinity_scheduling_test.go
T

1760 lines
63 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//go:build unit
package service
import (
"context"
"errors"
"sort"
"testing"
"time"
"github.com/Wei-Shaw/sub2api/internal/config"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
// ---------------------------------------------------------------------------
// Mock: GatewayCache for affinity tests
// ---------------------------------------------------------------------------
// mockAffinityCache 为亲和调度测试提供可控的 GatewayCache mock。
// 通过 getCountBatchFunc 可以自定义 GetAccountAffinityCountBatch 的行为。
type mockAffinityCache struct {
getCountBatchFunc func(ctx context.Context, groupID int64, accountIDs []int64, ttl time.Duration) (map[int64]int64, error)
getCountBatchCalls int // 记录 GetAccountAffinityCountBatch 被调用次数
}
func (m *mockAffinityCache) GetSessionAccountID(_ context.Context, _ int64, _ string) (int64, error) {
return 0, errors.New("not found")
}
func (m *mockAffinityCache) SetSessionAccountID(_ context.Context, _ int64, _ string, _ int64, _ time.Duration) error {
return nil
}
func (m *mockAffinityCache) RefreshSessionTTL(_ context.Context, _ int64, _ string, _ time.Duration) error {
return nil
}
func (m *mockAffinityCache) DeleteSessionAccountID(_ context.Context, _ int64, _ string) error {
return nil
}
func (m *mockAffinityCache) GetAffinityAccounts(_ context.Context, _ int64, _ int64, _ string, _ time.Duration) ([]int64, error) {
return nil, nil
}
func (m *mockAffinityCache) UpdateAffinity(_ context.Context, _ int64, _ int64, _ string, _ int64, _ time.Duration) error {
return nil
}
func (m *mockAffinityCache) GetAffinityMultiCount(_ context.Context, _ int64, _ int64, _ int64, _ time.Duration) (int64, int64, int64, error) {
return 0, 0, 0, nil
}
func (m *mockAffinityCache) GetAccountAffinityCountBatch(ctx context.Context, groupID int64, accountIDs []int64, ttl time.Duration) (map[int64]int64, error) {
m.getCountBatchCalls++
if m.getCountBatchFunc != nil {
return m.getCountBatchFunc(ctx, groupID, accountIDs, ttl)
}
return map[int64]int64{}, nil
}
func (m *mockAffinityCache) GetAccountAffinityClientsBatch(_ context.Context, _ map[int64][]int64, _ time.Duration) (map[int64][]string, error) {
return map[int64][]string{}, nil
}
func (m *mockAffinityCache) GetAccountAffinityClientsWithScores(_ context.Context, _ int64, _ []int64, _ time.Duration) ([]AffinityClient, error) {
return nil, nil
}
func (m *mockAffinityCache) ClearAccountAffinity(_ context.Context, _ int64, _ []int64) error {
return nil
}
// ---------------------------------------------------------------------------
// Helper: 构造启用了客户端亲和的 Anthropic 账号
// ---------------------------------------------------------------------------
func newAffinityAccount(id int64, priority int, affinityEnabled bool) *Account {
acc := &Account{
ID: id,
Platform: PlatformAnthropic,
Priority: priority,
Status: StatusActive,
}
if affinityEnabled {
acc.Extra = map[string]any{"client_affinity_enabled": true}
}
return acc
}
func newAffinityAccountWithLoad(id int64, priority int, loadRate int, affinityCount int64, lastUsedAt *time.Time) accountWithLoad {
return accountWithLoad{
account: newAffinityAccount(id, priority, true),
loadInfo: &AccountLoadInfo{AccountID: id, LoadRate: loadRate},
affinityCount: affinityCount,
}
}
// ===========================================================================
// 1. filterByMinAffinityCount 测试
// ===========================================================================
func TestAffinityFilterByMinAffinityCount(t *testing.T) {
t.Run("empty slice returns empty", func(t *testing.T) {
result := filterByMinAffinityCount(nil)
require.Empty(t, result)
})
t.Run("single element returned as-is", func(t *testing.T) {
accounts := []accountWithLoad{
{account: &Account{ID: 1}, loadInfo: &AccountLoadInfo{}, affinityCount: 5},
}
result := filterByMinAffinityCount(accounts)
require.Len(t, result, 1)
require.Equal(t, int64(1), result[0].account.ID)
})
t.Run("all same affinityCount returns all", func(t *testing.T) {
accounts := []accountWithLoad{
{account: &Account{ID: 1}, loadInfo: &AccountLoadInfo{}, affinityCount: 3},
{account: &Account{ID: 2}, loadInfo: &AccountLoadInfo{}, affinityCount: 3},
{account: &Account{ID: 3}, loadInfo: &AccountLoadInfo{}, affinityCount: 3},
}
result := filterByMinAffinityCount(accounts)
require.Len(t, result, 3)
})
t.Run("filters to min affinityCount only", func(t *testing.T) {
accounts := []accountWithLoad{
{account: &Account{ID: 1}, loadInfo: &AccountLoadInfo{}, affinityCount: 10},
{account: &Account{ID: 2}, loadInfo: &AccountLoadInfo{}, affinityCount: 2},
{account: &Account{ID: 3}, loadInfo: &AccountLoadInfo{}, affinityCount: 5},
{account: &Account{ID: 4}, loadInfo: &AccountLoadInfo{}, affinityCount: 2},
}
result := filterByMinAffinityCount(accounts)
require.Len(t, result, 2)
require.Equal(t, int64(2), result[0].account.ID)
require.Equal(t, int64(4), result[1].account.ID)
})
t.Run("zero affinityCount is smallest", func(t *testing.T) {
accounts := []accountWithLoad{
{account: &Account{ID: 1}, loadInfo: &AccountLoadInfo{}, affinityCount: 5},
{account: &Account{ID: 2}, loadInfo: &AccountLoadInfo{}, affinityCount: 0},
{account: &Account{ID: 3}, loadInfo: &AccountLoadInfo{}, affinityCount: 3},
{account: &Account{ID: 4}, loadInfo: &AccountLoadInfo{}, affinityCount: 0},
}
result := filterByMinAffinityCount(accounts)
require.Len(t, result, 2)
require.Equal(t, int64(2), result[0].account.ID)
require.Equal(t, int64(4), result[1].account.ID)
})
t.Run("preserves order within same affinityCount", func(t *testing.T) {
accounts := []accountWithLoad{
{account: &Account{ID: 5}, loadInfo: &AccountLoadInfo{}, affinityCount: 1},
{account: &Account{ID: 3}, loadInfo: &AccountLoadInfo{}, affinityCount: 1},
{account: &Account{ID: 7}, loadInfo: &AccountLoadInfo{}, affinityCount: 2},
{account: &Account{ID: 1}, loadInfo: &AccountLoadInfo{}, affinityCount: 1},
}
result := filterByMinAffinityCount(accounts)
require.Len(t, result, 3)
// 验证保持原始顺序
require.Equal(t, int64(5), result[0].account.ID)
require.Equal(t, int64(3), result[1].account.ID)
require.Equal(t, int64(1), result[2].account.ID)
})
}
// ===========================================================================
// 2. populateAffinityCounts 测试
// ===========================================================================
func TestAffinityPopulateAffinityCounts(t *testing.T) {
ctx := context.Background()
t.Run("nil cache does not panic", func(t *testing.T) {
svc := &GatewayService{cache: nil}
accounts := []accountWithLoad{
{account: newAffinityAccount(1, 1, true), loadInfo: &AccountLoadInfo{}},
}
// 不应 panic
svc.populateAffinityCounts(ctx, accounts, 0)
// affinityCount 保持零值
require.Equal(t, int64(0), accounts[0].affinityCount)
})
t.Run("empty accounts returns immediately", func(t *testing.T) {
cache := &mockAffinityCache{}
svc := &GatewayService{cache: cache}
svc.populateAffinityCounts(ctx, nil, 0)
require.Equal(t, 0, cache.getCountBatchCalls, "should not call Redis for empty accounts")
})
t.Run("no affinity-enabled accounts skips Redis call", func(t *testing.T) {
cache := &mockAffinityCache{}
svc := &GatewayService{cache: cache}
accounts := []accountWithLoad{
// Anthropic 但未启用亲和
{account: newAffinityAccount(1, 1, false), loadInfo: &AccountLoadInfo{}},
// 非 Anthropic 平台
{account: &Account{ID: 2, Platform: PlatformOpenAI}, loadInfo: &AccountLoadInfo{}},
}
svc.populateAffinityCounts(ctx, accounts, 0)
require.Equal(t, 0, cache.getCountBatchCalls, "should skip Redis when no affinity-enabled accounts")
})
t.Run("correctly populates affinityCount from Redis", func(t *testing.T) {
cache := &mockAffinityCache{
getCountBatchFunc: func(_ context.Context, _ int64, accountIDs []int64, _ time.Duration) (map[int64]int64, error) {
result := map[int64]int64{}
for _, id := range accountIDs {
switch id {
case 1:
result[1] = 5
case 2:
result[2] = 0
case 3:
result[3] = 12
}
}
return result, nil
},
}
svc := &GatewayService{cache: cache}
accounts := []accountWithLoad{
{account: newAffinityAccount(1, 1, true), loadInfo: &AccountLoadInfo{}},
{account: newAffinityAccount(2, 1, false), loadInfo: &AccountLoadInfo{}}, // 未启用,但仍在列表中
{account: newAffinityAccount(3, 1, true), loadInfo: &AccountLoadInfo{}},
}
svc.populateAffinityCounts(ctx, accounts, 100)
require.Equal(t, 1, cache.getCountBatchCalls, "should call Redis exactly once")
require.Equal(t, int64(5), accounts[0].affinityCount, "account 1 should have count 5")
require.Equal(t, int64(0), accounts[1].affinityCount, "account 2 should have count 0")
require.Equal(t, int64(12), accounts[2].affinityCount, "account 3 should have count 12")
})
t.Run("Redis error degrades gracefully with counts at 0", func(t *testing.T) {
cache := &mockAffinityCache{
getCountBatchFunc: func(_ context.Context, _ int64, _ []int64, _ time.Duration) (map[int64]int64, error) {
return nil, errors.New("redis connection refused")
},
}
svc := &GatewayService{cache: cache}
accounts := []accountWithLoad{
{account: newAffinityAccount(1, 1, true), loadInfo: &AccountLoadInfo{}},
{account: newAffinityAccount(2, 1, true), loadInfo: &AccountLoadInfo{}},
}
svc.populateAffinityCounts(ctx, accounts, 0)
require.Equal(t, 1, cache.getCountBatchCalls)
require.Equal(t, int64(0), accounts[0].affinityCount, "should remain 0 on error")
require.Equal(t, int64(0), accounts[1].affinityCount, "should remain 0 on error")
})
t.Run("partial Redis result fills only known accounts", func(t *testing.T) {
cache := &mockAffinityCache{
getCountBatchFunc: func(_ context.Context, _ int64, _ []int64, _ time.Duration) (map[int64]int64, error) {
// 只返回部分账号的计数
return map[int64]int64{1: 7}, nil
},
}
svc := &GatewayService{cache: cache}
accounts := []accountWithLoad{
{account: newAffinityAccount(1, 1, true), loadInfo: &AccountLoadInfo{}},
{account: newAffinityAccount(2, 1, true), loadInfo: &AccountLoadInfo{}},
}
svc.populateAffinityCounts(ctx, accounts, 0)
require.Equal(t, int64(7), accounts[0].affinityCount)
require.Equal(t, int64(0), accounts[1].affinityCount, "missing account should default to 0")
})
t.Run("queries all account IDs regardless of affinity status", func(t *testing.T) {
// 验证:只要有至少一个 affinity-enabled 账号,就查询 ALL 账号的计数
var queriedIDs []int64
cache := &mockAffinityCache{
getCountBatchFunc: func(_ context.Context, _ int64, accountIDs []int64, _ time.Duration) (map[int64]int64, error) {
queriedIDs = accountIDs
return map[int64]int64{}, nil
},
}
svc := &GatewayService{cache: cache}
accounts := []accountWithLoad{
{account: newAffinityAccount(1, 1, true), loadInfo: &AccountLoadInfo{}},
{account: newAffinityAccount(2, 1, false), loadInfo: &AccountLoadInfo{}},
{account: &Account{ID: 3, Platform: PlatformOpenAI}, loadInfo: &AccountLoadInfo{}},
}
svc.populateAffinityCounts(ctx, accounts, 0)
require.Equal(t, 1, cache.getCountBatchCalls)
require.Equal(t, []int64{1, 2, 3}, queriedIDs, "should query ALL account IDs, not just affinity-enabled ones")
})
}
// ===========================================================================
// 3. Layer 1 排序链测试(sort.SliceStable 中 affinityCount 的正确性)
// ===========================================================================
func TestAffinityLayer1SortChain(t *testing.T) {
now := time.Now()
earlier := now.Add(-1 * time.Hour)
muchEarlier := now.Add(-2 * time.Hour)
// 复现 Layer 1 的排序逻辑
sortByLayer1 := func(accounts []accountWithLoad) {
sort.SliceStable(accounts, func(i, j int) bool {
a, b := accounts[i], accounts[j]
if a.account.Priority != b.account.Priority {
return a.account.Priority < b.account.Priority
}
if a.loadInfo.LoadRate != b.loadInfo.LoadRate {
return a.loadInfo.LoadRate < b.loadInfo.LoadRate
}
if a.affinityCount != b.affinityCount {
return a.affinityCount < b.affinityCount
}
switch {
case a.account.LastUsedAt == nil && b.account.LastUsedAt != nil:
return true
case a.account.LastUsedAt != nil && b.account.LastUsedAt == nil:
return false
case a.account.LastUsedAt == nil && b.account.LastUsedAt == nil:
return false
default:
return a.account.LastUsedAt.Before(*b.account.LastUsedAt)
}
})
}
t.Run("same priority same loadRate sorts by affinityCount asc", func(t *testing.T) {
accounts := []accountWithLoad{
{account: &Account{ID: 1, Priority: 1, LastUsedAt: &now}, loadInfo: &AccountLoadInfo{LoadRate: 50}, affinityCount: 10},
{account: &Account{ID: 2, Priority: 1, LastUsedAt: &now}, loadInfo: &AccountLoadInfo{LoadRate: 50}, affinityCount: 2},
{account: &Account{ID: 3, Priority: 1, LastUsedAt: &now}, loadInfo: &AccountLoadInfo{LoadRate: 50}, affinityCount: 5},
}
sortByLayer1(accounts)
require.Equal(t, int64(2), accounts[0].account.ID, "lowest affinityCount first")
require.Equal(t, int64(3), accounts[1].account.ID)
require.Equal(t, int64(1), accounts[2].account.ID, "highest affinityCount last")
})
t.Run("priority takes precedence over affinityCount", func(t *testing.T) {
accounts := []accountWithLoad{
{account: &Account{ID: 1, Priority: 2, LastUsedAt: &now}, loadInfo: &AccountLoadInfo{LoadRate: 50}, affinityCount: 0},
{account: &Account{ID: 2, Priority: 1, LastUsedAt: &now}, loadInfo: &AccountLoadInfo{LoadRate: 50}, affinityCount: 100},
}
sortByLayer1(accounts)
require.Equal(t, int64(2), accounts[0].account.ID, "lower priority wins despite higher affinityCount")
})
t.Run("loadRate takes precedence over affinityCount", func(t *testing.T) {
accounts := []accountWithLoad{
{account: &Account{ID: 1, Priority: 1, LastUsedAt: &now}, loadInfo: &AccountLoadInfo{LoadRate: 80}, affinityCount: 0},
{account: &Account{ID: 2, Priority: 1, LastUsedAt: &now}, loadInfo: &AccountLoadInfo{LoadRate: 20}, affinityCount: 100},
}
sortByLayer1(accounts)
require.Equal(t, int64(2), accounts[0].account.ID, "lower loadRate wins despite higher affinityCount")
})
t.Run("affinityCount takes precedence over LRU", func(t *testing.T) {
accounts := []accountWithLoad{
{account: &Account{ID: 1, Priority: 1, LastUsedAt: &muchEarlier}, loadInfo: &AccountLoadInfo{LoadRate: 50}, affinityCount: 5},
{account: &Account{ID: 2, Priority: 1, LastUsedAt: &now}, loadInfo: &AccountLoadInfo{LoadRate: 50}, affinityCount: 1},
}
sortByLayer1(accounts)
require.Equal(t, int64(2), accounts[0].account.ID, "lower affinityCount wins despite older LRU")
})
t.Run("same affinityCount falls through to LRU", func(t *testing.T) {
accounts := []accountWithLoad{
{account: &Account{ID: 1, Priority: 1, LastUsedAt: &now}, loadInfo: &AccountLoadInfo{LoadRate: 50}, affinityCount: 3},
{account: &Account{ID: 2, Priority: 1, LastUsedAt: &earlier}, loadInfo: &AccountLoadInfo{LoadRate: 50}, affinityCount: 3},
{account: &Account{ID: 3, Priority: 1, LastUsedAt: &muchEarlier}, loadInfo: &AccountLoadInfo{LoadRate: 50}, affinityCount: 3},
}
sortByLayer1(accounts)
require.Equal(t, int64(3), accounts[0].account.ID, "LRU: oldest used first")
require.Equal(t, int64(2), accounts[1].account.ID)
require.Equal(t, int64(1), accounts[2].account.ID, "LRU: most recently used last")
})
t.Run("full chain: priority > loadRate > affinityCount > LRU", func(t *testing.T) {
accounts := []accountWithLoad{
// 优先级 2 - 不管其他维度如何,排在后面
{account: &Account{ID: 10, Priority: 2, LastUsedAt: &muchEarlier}, loadInfo: &AccountLoadInfo{LoadRate: 0}, affinityCount: 0},
// 优先级 1,负载 80% - 负载高
{account: &Account{ID: 20, Priority: 1, LastUsedAt: &muchEarlier}, loadInfo: &AccountLoadInfo{LoadRate: 80}, affinityCount: 0},
// 优先级 1,负载 20%,亲和 5
{account: &Account{ID: 30, Priority: 1, LastUsedAt: &muchEarlier}, loadInfo: &AccountLoadInfo{LoadRate: 20}, affinityCount: 5},
// 优先级 1,负载 20%,亲和 1,最近使用
{account: &Account{ID: 40, Priority: 1, LastUsedAt: &now}, loadInfo: &AccountLoadInfo{LoadRate: 20}, affinityCount: 1},
// 优先级 1,负载 20%,亲和 1,更早使用(应排最前)
{account: &Account{ID: 50, Priority: 1, LastUsedAt: &earlier}, loadInfo: &AccountLoadInfo{LoadRate: 20}, affinityCount: 1},
}
sortByLayer1(accounts)
// 期望排序:50 → 40 → 30 → 20 → 10
require.Equal(t, int64(50), accounts[0].account.ID, "best: p1, lr20, ac1, LRU earlier")
require.Equal(t, int64(40), accounts[1].account.ID, "second: p1, lr20, ac1, LRU now")
require.Equal(t, int64(30), accounts[2].account.ID, "third: p1, lr20, ac5")
require.Equal(t, int64(20), accounts[3].account.ID, "fourth: p1, lr80")
require.Equal(t, int64(10), accounts[4].account.ID, "last: p2")
})
}
// ===========================================================================
// 4. Layer 2 分层过滤链完整性测试
// ===========================================================================
func TestAffinityLayer2FilterChain(t *testing.T) {
now := time.Now()
earlier := now.Add(-1 * time.Hour)
muchEarlier := now.Add(-2 * time.Hour)
// 模拟 Layer 2 的完整过滤链:Priority → LoadRate → AffinityCount → LRU
applyLayer2 := func(accounts []accountWithLoad) *accountWithLoad {
candidates := filterByMinPriority(accounts)
candidates = filterByMinLoadRate(candidates)
candidates = filterByMinAffinityCount(candidates)
return selectByLRU(candidates, false)
}
t.Run("priority different - affinityCount does not matter", func(t *testing.T) {
accounts := []accountWithLoad{
{account: &Account{ID: 1, Priority: 2, LastUsedAt: &muchEarlier}, loadInfo: &AccountLoadInfo{LoadRate: 0}, affinityCount: 0},
{account: &Account{ID: 2, Priority: 1, LastUsedAt: &now}, loadInfo: &AccountLoadInfo{LoadRate: 50}, affinityCount: 100},
}
selected := applyLayer2(accounts)
require.NotNil(t, selected)
require.Equal(t, int64(2), selected.account.ID, "higher priority dimension overrides affinityCount")
})
t.Run("same priority same loadRate different affinityCount", func(t *testing.T) {
accounts := []accountWithLoad{
{account: &Account{ID: 1, Priority: 1, LastUsedAt: &now}, loadInfo: &AccountLoadInfo{LoadRate: 30}, affinityCount: 10},
{account: &Account{ID: 2, Priority: 1, LastUsedAt: &now}, loadInfo: &AccountLoadInfo{LoadRate: 30}, affinityCount: 2},
{account: &Account{ID: 3, Priority: 1, LastUsedAt: &now}, loadInfo: &AccountLoadInfo{LoadRate: 30}, affinityCount: 5},
}
selected := applyLayer2(accounts)
require.NotNil(t, selected)
require.Equal(t, int64(2), selected.account.ID, "lowest affinityCount wins")
})
t.Run("same priority same loadRate same affinityCount falls through to LRU", func(t *testing.T) {
accounts := []accountWithLoad{
{account: &Account{ID: 1, Priority: 1, LastUsedAt: &now}, loadInfo: &AccountLoadInfo{LoadRate: 30}, affinityCount: 5},
{account: &Account{ID: 2, Priority: 1, LastUsedAt: &earlier}, loadInfo: &AccountLoadInfo{LoadRate: 30}, affinityCount: 5},
{account: &Account{ID: 3, Priority: 1, LastUsedAt: &muchEarlier}, loadInfo: &AccountLoadInfo{LoadRate: 30}, affinityCount: 5},
}
selected := applyLayer2(accounts)
require.NotNil(t, selected)
require.Equal(t, int64(3), selected.account.ID, "LRU selects oldest")
})
t.Run("loadRate different overrides affinityCount", func(t *testing.T) {
accounts := []accountWithLoad{
{account: &Account{ID: 1, Priority: 1, LastUsedAt: &now}, loadInfo: &AccountLoadInfo{LoadRate: 80}, affinityCount: 0},
{account: &Account{ID: 2, Priority: 1, LastUsedAt: &now}, loadInfo: &AccountLoadInfo{LoadRate: 10}, affinityCount: 100},
}
selected := applyLayer2(accounts)
require.NotNil(t, selected)
require.Equal(t, int64(2), selected.account.ID, "lower loadRate wins over lower affinityCount")
})
t.Run("full chain integration: p → lr → ac → lru", func(t *testing.T) {
accounts := []accountWithLoad{
// p=2 淘汰
{account: &Account{ID: 1, Priority: 2, LastUsedAt: &muchEarlier}, loadInfo: &AccountLoadInfo{LoadRate: 0}, affinityCount: 0},
// p=1, lr=50 淘汰
{account: &Account{ID: 2, Priority: 1, LastUsedAt: &muchEarlier}, loadInfo: &AccountLoadInfo{LoadRate: 50}, affinityCount: 0},
// p=1, lr=10, ac=8 淘汰
{account: &Account{ID: 3, Priority: 1, LastUsedAt: &muchEarlier}, loadInfo: &AccountLoadInfo{LoadRate: 10}, affinityCount: 8},
// p=1, lr=10, ac=2, lru=now 淘汰
{account: &Account{ID: 4, Priority: 1, LastUsedAt: &now}, loadInfo: &AccountLoadInfo{LoadRate: 10}, affinityCount: 2},
// p=1, lr=10, ac=2, lru=muchEarlier → 胜出
{account: &Account{ID: 5, Priority: 1, LastUsedAt: &muchEarlier}, loadInfo: &AccountLoadInfo{LoadRate: 10}, affinityCount: 2},
}
selected := applyLayer2(accounts)
require.NotNil(t, selected)
require.Equal(t, int64(5), selected.account.ID, "full chain selects ID=5")
})
t.Run("empty input returns nil", func(t *testing.T) {
selected := applyLayer2(nil)
require.Nil(t, selected)
})
t.Run("single account always selected", func(t *testing.T) {
accounts := []accountWithLoad{
{account: &Account{ID: 42, Priority: 1, LastUsedAt: &now}, loadInfo: &AccountLoadInfo{LoadRate: 50}, affinityCount: 100},
}
selected := applyLayer2(accounts)
require.NotNil(t, selected)
require.Equal(t, int64(42), selected.account.ID)
})
t.Run("affinityCount zero preferred among same p and lr", func(t *testing.T) {
accounts := []accountWithLoad{
{account: &Account{ID: 1, Priority: 1, LastUsedAt: &now}, loadInfo: &AccountLoadInfo{LoadRate: 0}, affinityCount: 5},
{account: &Account{ID: 2, Priority: 1, LastUsedAt: &now}, loadInfo: &AccountLoadInfo{LoadRate: 0}, affinityCount: 0},
{account: &Account{ID: 3, Priority: 1, LastUsedAt: &now}, loadInfo: &AccountLoadInfo{LoadRate: 0}, affinityCount: 3},
}
selected := applyLayer2(accounts)
require.NotNil(t, selected)
require.Equal(t, int64(2), selected.account.ID, "zero affinityCount preferred")
})
}
// ===========================================================================
// 5. populateAffinityCounts + filterByMinAffinityCount 联合测试
// ===========================================================================
func TestAffinityPopulateAndFilterIntegration(t *testing.T) {
ctx := context.Background()
t.Run("populate then filter selects least-loaded accounts", func(t *testing.T) {
cache := &mockAffinityCache{
getCountBatchFunc: func(_ context.Context, _ int64, _ []int64, _ time.Duration) (map[int64]int64, error) {
return map[int64]int64{
1: 10,
2: 3,
3: 3,
4: 7,
}, nil
},
}
svc := &GatewayService{cache: cache}
accounts := []accountWithLoad{
{account: newAffinityAccount(1, 1, true), loadInfo: &AccountLoadInfo{}},
{account: newAffinityAccount(2, 1, true), loadInfo: &AccountLoadInfo{}},
{account: newAffinityAccount(3, 1, true), loadInfo: &AccountLoadInfo{}},
{account: newAffinityAccount(4, 1, true), loadInfo: &AccountLoadInfo{}},
}
svc.populateAffinityCounts(ctx, accounts, 0)
result := filterByMinAffinityCount(accounts)
require.Len(t, result, 2)
require.Equal(t, int64(2), result[0].account.ID)
require.Equal(t, int64(3), result[1].account.ID)
})
t.Run("Redis failure results in all accounts having 0 affinityCount", func(t *testing.T) {
cache := &mockAffinityCache{
getCountBatchFunc: func(_ context.Context, _ int64, _ []int64, _ time.Duration) (map[int64]int64, error) {
return nil, errors.New("timeout")
},
}
svc := &GatewayService{cache: cache}
accounts := []accountWithLoad{
{account: newAffinityAccount(1, 1, true), loadInfo: &AccountLoadInfo{}},
{account: newAffinityAccount(2, 1, true), loadInfo: &AccountLoadInfo{}},
}
svc.populateAffinityCounts(ctx, accounts, 0)
result := filterByMinAffinityCount(accounts)
// 全部为 0,全部返回
require.Len(t, result, 2, "all accounts should pass filter when Redis fails (all have count 0)")
})
}
// ===========================================================================
// 6. IsClientAffinityEnabled 边界测试
// ===========================================================================
func TestAffinityIsClientAffinityEnabled(t *testing.T) {
t.Run("Anthropic with enabled flag", func(t *testing.T) {
acc := &Account{
Platform: PlatformAnthropic,
Extra: map[string]any{"client_affinity_enabled": true},
}
assert.True(t, acc.IsClientAffinityEnabled())
})
t.Run("Anthropic with disabled flag", func(t *testing.T) {
acc := &Account{
Platform: PlatformAnthropic,
Extra: map[string]any{"client_affinity_enabled": false},
}
assert.False(t, acc.IsClientAffinityEnabled())
})
t.Run("Anthropic with nil Extra", func(t *testing.T) {
acc := &Account{
Platform: PlatformAnthropic,
Extra: nil,
}
assert.False(t, acc.IsClientAffinityEnabled())
})
t.Run("Anthropic without the key", func(t *testing.T) {
acc := &Account{
Platform: PlatformAnthropic,
Extra: map[string]any{"other_key": true},
}
assert.False(t, acc.IsClientAffinityEnabled())
})
t.Run("non-Anthropic platform always false", func(t *testing.T) {
platforms := []string{PlatformOpenAI, PlatformGemini, PlatformAntigravity}
for _, p := range platforms {
acc := &Account{
Platform: p,
Extra: map[string]any{"client_affinity_enabled": true},
}
assert.False(t, acc.IsClientAffinityEnabled(), "platform=%s should not support affinity", p)
}
})
t.Run("wrong type for enabled value", func(t *testing.T) {
acc := &Account{
Platform: PlatformAnthropic,
Extra: map[string]any{"client_affinity_enabled": "true"}, // string 而非 bool
}
assert.False(t, acc.IsClientAffinityEnabled(), "string 'true' should not enable affinity")
})
t.Run("new flag false overrides legacy flag true", func(t *testing.T) {
acc := &Account{
Platform: PlatformAnthropic,
Extra: map[string]any{
"affinity_enabled": false,
"client_affinity_enabled": true,
},
}
assert.False(t, acc.IsClientAffinityEnabled())
})
t.Run("new flag true overrides legacy flag false", func(t *testing.T) {
acc := &Account{
Platform: PlatformAnthropic,
Extra: map[string]any{
"affinity_enabled": true,
"client_affinity_enabled": false,
},
}
assert.True(t, acc.IsClientAffinityEnabled())
})
}
// ===========================================================================
// GetAffinityZone 测试
// ===========================================================================
func TestGetAffinityZone(t *testing.T) {
makeAccount := func(enabled bool, base int, buffer any) *Account {
extra := map[string]any{"client_affinity_enabled": enabled}
if base > 0 {
extra["affinity_base"] = base
}
if buffer != nil {
extra["affinity_buffer"] = buffer
}
return &Account{
Platform: PlatformAnthropic,
Extra: extra,
}
}
t.Run("affinity disabled always green", func(t *testing.T) {
acc := makeAccount(false, 5, 3)
assert.Equal(t, AffinityZoneGreen, acc.GetAffinityZone(100))
})
t.Run("no base configured always green", func(t *testing.T) {
acc := makeAccount(true, 0, nil)
assert.Equal(t, AffinityZoneGreen, acc.GetAffinityZone(100))
})
t.Run("within base limit is green", func(t *testing.T) {
acc := makeAccount(true, 5, 3)
assert.Equal(t, AffinityZoneGreen, acc.GetAffinityZone(0))
assert.Equal(t, AffinityZoneGreen, acc.GetAffinityZone(3))
assert.Equal(t, AffinityZoneGreen, acc.GetAffinityZone(5))
})
t.Run("no buffer configured infinite yellow", func(t *testing.T) {
acc := makeAccount(true, 5, nil) // buffer not set → infinite yellow
assert.Equal(t, AffinityZoneYellow, acc.GetAffinityZone(6))
assert.Equal(t, AffinityZoneYellow, acc.GetAffinityZone(100))
assert.Equal(t, AffinityZoneYellow, acc.GetAffinityZone(9999))
})
t.Run("buffer zero no yellow zone", func(t *testing.T) {
acc := makeAccount(true, 5, 0) // buffer=0 → no yellow, direct red
assert.Equal(t, AffinityZoneGreen, acc.GetAffinityZone(5))
assert.Equal(t, AffinityZoneRed, acc.GetAffinityZone(6))
assert.Equal(t, AffinityZoneRed, acc.GetAffinityZone(100))
})
t.Run("within buffer is yellow", func(t *testing.T) {
acc := makeAccount(true, 5, 3)
assert.Equal(t, AffinityZoneYellow, acc.GetAffinityZone(6))
assert.Equal(t, AffinityZoneYellow, acc.GetAffinityZone(7))
assert.Equal(t, AffinityZoneYellow, acc.GetAffinityZone(8)) // base(5)+buffer(3)=8
})
t.Run("beyond buffer is red", func(t *testing.T) {
acc := makeAccount(true, 5, 3)
assert.Equal(t, AffinityZoneRed, acc.GetAffinityZone(9))
assert.Equal(t, AffinityZoneRed, acc.GetAffinityZone(100))
})
t.Run("boundary exactly at base", func(t *testing.T) {
acc := makeAccount(true, 10, 5)
assert.Equal(t, AffinityZoneGreen, acc.GetAffinityZone(10))
assert.Equal(t, AffinityZoneYellow, acc.GetAffinityZone(11))
})
t.Run("boundary exactly at base plus buffer", func(t *testing.T) {
acc := makeAccount(true, 10, 5)
assert.Equal(t, AffinityZoneYellow, acc.GetAffinityZone(15))
assert.Equal(t, AffinityZoneRed, acc.GetAffinityZone(16))
})
}
// ===========================================================================
// classifyByAffinityZone 测试
// ===========================================================================
func TestClassifyByAffinityZone(t *testing.T) {
makeAWL := func(id int64, base int, buffer any, count int64) accountWithLoad {
extra := map[string]any{"client_affinity_enabled": true}
if base > 0 {
extra["affinity_base"] = base
}
if buffer != nil {
extra["affinity_buffer"] = buffer
}
return accountWithLoad{
account: &Account{ID: id, Platform: PlatformAnthropic, Extra: extra},
loadInfo: &AccountLoadInfo{AccountID: id},
affinityCount: count,
}
}
t.Run("empty input returns empty", func(t *testing.T) {
result := classifyByAffinityZone(nil)
require.Empty(t, result)
})
t.Run("no zone config returns all", func(t *testing.T) {
// 没有账号配置 affinity_base → 原样返回
accs := []accountWithLoad{
{account: newAffinityAccount(1, 50, true), loadInfo: &AccountLoadInfo{AccountID: 1}},
{account: newAffinityAccount(2, 50, true), loadInfo: &AccountLoadInfo{AccountID: 2}},
}
result := classifyByAffinityZone(accs)
require.Len(t, result, 2)
})
t.Run("greens preferred over yellows", func(t *testing.T) {
accs := []accountWithLoad{
makeAWL(1, 5, 3, 3), // green (3 ≤ 5)
makeAWL(2, 5, 3, 7), // yellow (5 < 7 ≤ 8)
makeAWL(3, 5, 3, 2), // green (2 ≤ 5)
}
result := classifyByAffinityZone(accs)
require.Len(t, result, 2)
ids := []int64{result[0].account.ID, result[1].account.ID}
sort.Slice(ids, func(i, j int) bool { return ids[i] < ids[j] })
assert.Equal(t, []int64{1, 3}, ids)
})
t.Run("reds excluded", func(t *testing.T) {
accs := []accountWithLoad{
makeAWL(1, 5, 3, 10), // red (10 > 8)
makeAWL(2, 5, 3, 6), // yellow (5 < 6 ≤ 8)
makeAWL(3, 5, 3, 9), // red (9 > 8)
}
result := classifyByAffinityZone(accs)
require.Len(t, result, 1)
assert.Equal(t, int64(2), result[0].account.ID)
})
t.Run("all red returns empty", func(t *testing.T) {
accs := []accountWithLoad{
makeAWL(1, 5, 0, 6), // buffer=0 → red (6 > 5)
makeAWL(2, 5, 0, 10), // buffer=0 → red (10 > 5)
}
result := classifyByAffinityZone(accs)
require.Empty(t, result)
})
t.Run("mixed with unconfigured accounts", func(t *testing.T) {
// 账号 1: 配置了 base=5,buffer=3 → green(3≤5)
// 账号 2: 未配置 base → 视为 green
// 账号 3: 配置了 base=5,buffer=3 → red(10>8)
accs := []accountWithLoad{
makeAWL(1, 5, 3, 3),
{account: newAffinityAccount(2, 50, true), loadInfo: &AccountLoadInfo{AccountID: 2}, affinityCount: 20},
makeAWL(3, 5, 3, 10),
}
result := classifyByAffinityZone(accs)
require.Len(t, result, 2)
ids := []int64{result[0].account.ID, result[1].account.ID}
sort.Slice(ids, func(i, j int) bool { return ids[i] < ids[j] })
assert.Equal(t, []int64{1, 2}, ids)
})
t.Run("infinite yellow never reds", func(t *testing.T) {
// buffer 未配置 → 无限黄区,永不红区
accs := []accountWithLoad{
makeAWL(1, 5, nil, 100), // yellow (100 > 5, no buffer → infinite yellow)
makeAWL(2, 5, nil, 3), // green (3 ≤ 5)
}
result := classifyByAffinityZone(accs)
// green 优先
require.Len(t, result, 1)
assert.Equal(t, int64(2), result[0].account.ID)
})
t.Run("only yellows when no greens", func(t *testing.T) {
accs := []accountWithLoad{
makeAWL(1, 5, nil, 10), // yellow
makeAWL(2, 5, nil, 20), // yellow
}
result := classifyByAffinityZone(accs)
require.Len(t, result, 2)
})
}
// ===========================================================================
// GetMultiDimAffinityZone 测试
// ===========================================================================
func TestGetMultiDimAffinityZone(t *testing.T) {
makeAccount := func(opts map[string]any) *Account {
extra := map[string]any{"affinity_enabled": true}
for k, v := range opts {
extra[k] = v
}
return &Account{
Platform: PlatformAnthropic,
Extra: extra,
}
}
t.Run("user green + client green = green", func(t *testing.T) {
acc := makeAccount(map[string]any{
"affinity_base": 10,
"affinity_buffer": 5,
"affinity_user_base": 3,
"affinity_user_buffer": 2,
})
assert.Equal(t, AffinityZoneGreen, acc.GetMultiDimAffinityZone(2, 5, 0))
})
t.Run("user green + client yellow = yellow", func(t *testing.T) {
acc := makeAccount(map[string]any{
"affinity_base": 10,
"affinity_buffer": 5,
"affinity_user_base": 3,
"affinity_user_buffer": 2,
})
assert.Equal(t, AffinityZoneYellow, acc.GetMultiDimAffinityZone(2, 12, 0))
})
t.Run("user yellow + client green = yellow", func(t *testing.T) {
acc := makeAccount(map[string]any{
"affinity_base": 10,
"affinity_buffer": 5,
"affinity_user_base": 3,
"affinity_user_buffer": 2,
})
assert.Equal(t, AffinityZoneYellow, acc.GetMultiDimAffinityZone(4, 5, 0))
})
t.Run("user red + client green = red", func(t *testing.T) {
acc := makeAccount(map[string]any{
"affinity_base": 10,
"affinity_buffer": 5,
"affinity_user_base": 3,
"affinity_user_buffer": 0, // no yellow, direct red
})
assert.Equal(t, AffinityZoneRed, acc.GetMultiDimAffinityZone(4, 5, 0))
})
t.Run("user green + client red = red", func(t *testing.T) {
acc := makeAccount(map[string]any{
"affinity_base": 10,
"affinity_buffer": 0, // no yellow, direct red
"affinity_user_base": 3,
"affinity_user_buffer": 2,
})
assert.Equal(t, AffinityZoneRed, acc.GetMultiDimAffinityZone(2, 11, 0))
})
t.Run("user_base=0 only checks client dimension", func(t *testing.T) {
acc := makeAccount(map[string]any{
"affinity_base": 10,
"affinity_buffer": 5,
// no affinity_user_base → 0 → user dimension always green
})
// client in yellow range
assert.Equal(t, AffinityZoneYellow, acc.GetMultiDimAffinityZone(100, 12, 0))
})
t.Run("perUserCount exceeds limit = red", func(t *testing.T) {
acc := makeAccount(map[string]any{
"affinity_base": 10,
"affinity_buffer": 5,
"per_user_client_limit": 3,
})
// client green, user green, but perUser > limit
assert.Equal(t, AffinityZoneRed, acc.GetMultiDimAffinityZone(1, 5, 4))
})
t.Run("perUserCount within limit = green", func(t *testing.T) {
acc := makeAccount(map[string]any{
"affinity_base": 10,
"affinity_buffer": 5,
"per_user_client_limit": 3,
})
assert.Equal(t, AffinityZoneGreen, acc.GetMultiDimAffinityZone(1, 5, 3))
})
t.Run("affinity disabled always green", func(t *testing.T) {
acc := &Account{
Platform: PlatformAnthropic,
Extra: map[string]any{
"affinity_enabled": false,
"affinity_base": 1,
"affinity_buffer": 0,
},
}
assert.Equal(t, AffinityZoneGreen, acc.GetMultiDimAffinityZone(100, 100, 100))
})
}
// ===========================================================================
// IsAffinityAllowSwitch 测试
// ===========================================================================
func TestIsAffinityAllowSwitch(t *testing.T) {
t.Run("default true when no field in Extra", func(t *testing.T) {
acc := &Account{
Platform: PlatformAnthropic,
Extra: map[string]any{"affinity_enabled": true},
}
assert.True(t, acc.IsAffinityAllowSwitch())
})
t.Run("explicit false", func(t *testing.T) {
acc := &Account{
Platform: PlatformAnthropic,
Extra: map[string]any{"affinity_allow_switch": false},
}
assert.False(t, acc.IsAffinityAllowSwitch())
})
t.Run("Extra nil defaults to true", func(t *testing.T) {
acc := &Account{
Platform: PlatformAnthropic,
Extra: nil,
}
assert.True(t, acc.IsAffinityAllowSwitch())
})
t.Run("explicit true", func(t *testing.T) {
acc := &Account{
Platform: PlatformAnthropic,
Extra: map[string]any{"affinity_allow_switch": true},
}
assert.True(t, acc.IsAffinityAllowSwitch())
})
}
// ===========================================================================
// GetPinnedUsers / IsPinnedUser 测试
// ===========================================================================
func TestGetPinnedUsers(t *testing.T) {
t.Run("normal list", func(t *testing.T) {
acc := &Account{
Platform: PlatformAnthropic,
Extra: map[string]any{
"pinned_users": []any{float64(10), float64(20), float64(30)},
},
}
result := acc.GetPinnedUsers()
assert.Equal(t, []int64{10, 20, 30}, result)
})
t.Run("empty list", func(t *testing.T) {
acc := &Account{
Platform: PlatformAnthropic,
Extra: map[string]any{
"pinned_users": []any{},
},
}
result := acc.GetPinnedUsers()
assert.Nil(t, result)
})
t.Run("Extra nil", func(t *testing.T) {
acc := &Account{
Platform: PlatformAnthropic,
Extra: nil,
}
result := acc.GetPinnedUsers()
assert.Nil(t, result)
})
t.Run("pinned_users not set", func(t *testing.T) {
acc := &Account{
Platform: PlatformAnthropic,
Extra: map[string]any{},
}
result := acc.GetPinnedUsers()
assert.Nil(t, result)
})
}
func TestIsPinnedUser(t *testing.T) {
acc := &Account{
Platform: PlatformAnthropic,
Extra: map[string]any{
"pinned_users": []any{float64(10), float64(20), float64(30)},
},
}
t.Run("hit", func(t *testing.T) {
assert.True(t, acc.IsPinnedUser(20))
})
t.Run("miss", func(t *testing.T) {
assert.False(t, acc.IsPinnedUser(99))
})
t.Run("nil Extra", func(t *testing.T) {
nilAcc := &Account{Platform: PlatformAnthropic, Extra: nil}
assert.False(t, nilAcc.IsPinnedUser(10))
})
}
// ===========================================================================
// Enhanced mock for integration tests (supports affinity lookups + tracking)
// ===========================================================================
type affinityIntegrationCache struct {
mockAffinityCache
getAffinityAccountsFunc func(ctx context.Context, groupID int64, userID int64, clientID string, ttl time.Duration) ([]int64, error)
updateAffinityCalls []affinityUpdateCall
getMultiCountFunc func(ctx context.Context, groupID int64, accountID int64, targetUserID int64, ttl time.Duration) (int64, int64, int64, error)
sessionBindings map[string]int64
getAffinityAccountsCalled bool // 标记 GetAffinityAccounts 是否已被调用,用于区分预处理/Layer 2 阶段
}
type affinityUpdateCall struct {
groupID int64
userID int64
clientID string
accountID int64
beforeAffinityLookup bool // true 表示该调用发生在 GetAffinityAccounts 之前(预处理阶段)
}
func (c *affinityIntegrationCache) GetSessionAccountID(_ context.Context, _ int64, hash string) (int64, error) {
if c.sessionBindings != nil {
if id, ok := c.sessionBindings[hash]; ok {
return id, nil
}
}
return 0, errors.New("not found")
}
func (c *affinityIntegrationCache) GetAffinityAccounts(ctx context.Context, groupID int64, userID int64, clientID string, ttl time.Duration) ([]int64, error) {
c.getAffinityAccountsCalled = true
if c.getAffinityAccountsFunc != nil {
return c.getAffinityAccountsFunc(ctx, groupID, userID, clientID, ttl)
}
return nil, nil
}
func (c *affinityIntegrationCache) UpdateAffinity(_ context.Context, groupID int64, userID int64, clientID string, accountID int64, _ time.Duration) error {
c.updateAffinityCalls = append(c.updateAffinityCalls, affinityUpdateCall{
groupID: groupID, userID: userID, clientID: clientID, accountID: accountID,
beforeAffinityLookup: !c.getAffinityAccountsCalled,
})
return nil
}
func (c *affinityIntegrationCache) GetAffinityMultiCount(ctx context.Context, groupID int64, accountID int64, targetUserID int64, ttl time.Duration) (int64, int64, int64, error) {
if c.getMultiCountFunc != nil {
return c.getMultiCountFunc(ctx, groupID, accountID, targetUserID, ttl)
}
return 0, 0, 0, nil
}
// ===========================================================================
// TestAffinityPreprocessPinnedUsers — 验证 pinned_users 预处理逻辑
// ===========================================================================
func TestAffinityPreprocessPinnedUsers(t *testing.T) {
ctx := context.Background()
testUserID := int64(42)
testClientID := "user_" + "a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2" + "_account_test"
t.Run("pinned user triggers UpdateAffinity", func(t *testing.T) {
cache := &affinityIntegrationCache{}
repo := &mockAccountRepoForPlatform{
accounts: []Account{
{
ID: 1, Platform: PlatformAnthropic, Priority: 1,
Status: StatusActive, Schedulable: true, Concurrency: 5,
Extra: map[string]any{
"affinity_enabled": true,
"pinned_users": []any{float64(42)},
},
},
{
ID: 2, Platform: PlatformAnthropic, Priority: 1,
Status: StatusActive, Schedulable: true, Concurrency: 5,
Extra: map[string]any{"affinity_enabled": true},
},
},
accountsByID: map[int64]*Account{},
}
for i := range repo.accounts {
repo.accountsByID[repo.accounts[i].ID] = &repo.accounts[i]
}
concCache := &mockConcurrencyCache{acquireResults: map[int64]bool{1: true, 2: true}}
concSvc := NewConcurrencyService(concCache)
cfg := &config.Config{RunMode: config.RunModeStandard}
cfg.Gateway.Scheduling.LoadBatchEnabled = true
svc := &GatewayService{
accountRepo: repo,
cache: cache,
cfg: cfg,
concurrencyService: concSvc,
}
_, err := svc.SelectAccountWithLoadAwareness(ctx, nil, "", "claude-3-5-sonnet-20241022", nil, testClientID, testUserID)
require.NoError(t, err)
// 验证 UpdateAffinity 至少被调用了一次(pinned preprocess for account 1)
found := false
for _, call := range cache.updateAffinityCalls {
if call.accountID == 1 && call.userID == testUserID {
found = true
break
}
}
assert.True(t, found, "UpdateAffinity should be called for pinned account 1 with userID %d", testUserID)
})
t.Run("non-pinned user does not trigger UpdateAffinity preprocess", func(t *testing.T) {
cache := &affinityIntegrationCache{
getAffinityAccountsFunc: func(_ context.Context, _ int64, _ int64, _ string, _ time.Duration) ([]int64, error) {
return nil, nil // 无亲和记录,直接进入 Layer 2
},
}
repo := &mockAccountRepoForPlatform{
accounts: []Account{
{
ID: 1, Platform: PlatformAnthropic, Priority: 1,
Status: StatusActive, Schedulable: true, Concurrency: 5,
Extra: map[string]any{
"affinity_enabled": true,
"pinned_users": []any{float64(99)}, // different user
},
},
},
accountsByID: map[int64]*Account{},
}
for i := range repo.accounts {
repo.accountsByID[repo.accounts[i].ID] = &repo.accounts[i]
}
concCache := &mockConcurrencyCache{acquireResults: map[int64]bool{1: true}}
concSvc := NewConcurrencyService(concCache)
cfg := &config.Config{RunMode: config.RunModeStandard}
cfg.Gateway.Scheduling.LoadBatchEnabled = true
svc := &GatewayService{
accountRepo: repo,
cache: cache,
cfg: cfg,
concurrencyService: concSvc,
}
_, err := svc.SelectAccountWithLoadAwareness(ctx, nil, "", "claude-3-5-sonnet-20241022", nil, testClientID, testUserID)
require.NoError(t, err)
// 验证预处理阶段(beforeAffinityLookup=true)没有为 userID=42 在 account 1 上调用 UpdateAffinity
for _, call := range cache.updateAffinityCalls {
if call.beforeAffinityLookup && call.accountID == 1 && call.userID == testUserID {
t.Errorf("UpdateAffinity should NOT be called in preprocess for non-pinned user %d on account %d", testUserID, call.accountID)
}
}
})
}
// ===========================================================================
// TestAffinityNoSwitchError — 验证 ErrAffinityNoSwitch 行为
// ===========================================================================
func TestAffinityNoSwitchError(t *testing.T) {
ctx := context.Background()
testUserID := int64(42)
testClientID := "user_" + "a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2" + "_account_test"
futureTime := time.Now().Add(1 * time.Hour)
t.Run("affinity hit but unschedulable + allow_switch=false returns ErrAffinityNoSwitch", func(t *testing.T) {
cache := &affinityIntegrationCache{
getAffinityAccountsFunc: func(_ context.Context, _ int64, _ int64, _ string, _ time.Duration) ([]int64, error) {
return []int64{1}, nil
},
}
repo := &mockAccountRepoForPlatform{
accounts: []Account{
{
ID: 1, Platform: PlatformAnthropic, Priority: 1,
Status: StatusActive, Schedulable: true,
RateLimitResetAt: &futureTime, // rate limited = unschedulable for selection
Concurrency: 5,
Extra: map[string]any{
"affinity_enabled": true,
"affinity_allow_switch": false,
},
},
{
ID: 2, Platform: PlatformAnthropic, Priority: 1,
Status: StatusActive, Schedulable: true, Concurrency: 5,
},
},
accountsByID: map[int64]*Account{},
}
for i := range repo.accounts {
repo.accountsByID[repo.accounts[i].ID] = &repo.accounts[i]
}
concCache := &mockConcurrencyCache{acquireResults: map[int64]bool{2: true}}
concSvc := NewConcurrencyService(concCache)
cfg := &config.Config{RunMode: config.RunModeStandard}
cfg.Gateway.Scheduling.LoadBatchEnabled = true
svc := &GatewayService{
accountRepo: repo,
cache: cache,
cfg: cfg,
concurrencyService: concSvc,
}
_, err := svc.SelectAccountWithLoadAwareness(ctx, nil, "", "claude-3-5-sonnet-20241022", nil, testClientID, testUserID)
require.Error(t, err)
assert.ErrorIs(t, err, ErrAffinityNoSwitch)
})
t.Run("affinity hit but unschedulable + allow_switch=true continues to Layer 2", func(t *testing.T) {
cache := &affinityIntegrationCache{
getAffinityAccountsFunc: func(_ context.Context, _ int64, _ int64, _ string, _ time.Duration) ([]int64, error) {
return []int64{1}, nil
},
}
repo := &mockAccountRepoForPlatform{
accounts: []Account{
{
ID: 1, Platform: PlatformAnthropic, Priority: 1,
Status: StatusActive, Schedulable: true,
RateLimitResetAt: &futureTime, // rate limited = unschedulable
Concurrency: 5,
Extra: map[string]any{
"affinity_enabled": true,
"affinity_allow_switch": true,
},
},
{
ID: 2, Platform: PlatformAnthropic, Priority: 1,
Status: StatusActive, Schedulable: true, Concurrency: 5,
},
},
accountsByID: map[int64]*Account{},
}
for i := range repo.accounts {
repo.accountsByID[repo.accounts[i].ID] = &repo.accounts[i]
}
concCache := &mockConcurrencyCache{acquireResults: map[int64]bool{2: true}}
concSvc := NewConcurrencyService(concCache)
cfg := &config.Config{RunMode: config.RunModeStandard}
cfg.Gateway.Scheduling.LoadBatchEnabled = true
svc := &GatewayService{
accountRepo: repo,
cache: cache,
cfg: cfg,
concurrencyService: concSvc,
}
result, err := svc.SelectAccountWithLoadAwareness(ctx, nil, "", "claude-3-5-sonnet-20241022", nil, testClientID, testUserID)
require.NoError(t, err)
require.NotNil(t, result)
assert.Equal(t, int64(2), result.Account.ID, "should fall through to Layer 2 and select account 2")
})
t.Run("no affinity records - not affected by allow_switch", func(t *testing.T) {
cache := &affinityIntegrationCache{} // returns nil from GetAffinityAccounts
repo := &mockAccountRepoForPlatform{
accounts: []Account{
{
ID: 1, Platform: PlatformAnthropic, Priority: 1,
Status: StatusActive, Schedulable: true, Concurrency: 5,
Extra: map[string]any{
"affinity_enabled": true,
"affinity_allow_switch": false,
},
},
},
accountsByID: map[int64]*Account{},
}
for i := range repo.accounts {
repo.accountsByID[repo.accounts[i].ID] = &repo.accounts[i]
}
concCache := &mockConcurrencyCache{acquireResults: map[int64]bool{1: true}}
concSvc := NewConcurrencyService(concCache)
cfg := &config.Config{RunMode: config.RunModeStandard}
cfg.Gateway.Scheduling.LoadBatchEnabled = true
svc := &GatewayService{
accountRepo: repo,
cache: cache,
cfg: cfg,
concurrencyService: concSvc,
}
result, err := svc.SelectAccountWithLoadAwareness(ctx, nil, "", "claude-3-5-sonnet-20241022", nil, testClientID, testUserID)
require.NoError(t, err)
require.NotNil(t, result)
assert.Equal(t, int64(1), result.Account.ID, "should select normally via Layer 2")
})
t.Run("affinity disabled account ignores allow_switch=false", func(t *testing.T) {
cache := &affinityIntegrationCache{
getAffinityAccountsFunc: func(_ context.Context, _ int64, _ int64, _ string, _ time.Duration) ([]int64, error) {
return []int64{1}, nil
},
}
repo := &mockAccountRepoForPlatform{
accounts: []Account{
{
ID: 1, Platform: PlatformAnthropic, Priority: 1,
Status: StatusActive, Schedulable: true, Concurrency: 5,
Extra: map[string]any{
"affinity_enabled": false,
"affinity_allow_switch": false,
},
},
{
ID: 2, Platform: PlatformAnthropic, Priority: 2,
Status: StatusActive, Schedulable: true, Concurrency: 5,
},
},
accountsByID: map[int64]*Account{},
}
for i := range repo.accounts {
repo.accountsByID[repo.accounts[i].ID] = &repo.accounts[i]
}
concCache := &mockConcurrencyCache{acquireResults: map[int64]bool{2: true}}
concSvc := NewConcurrencyService(concCache)
cfg := &config.Config{RunMode: config.RunModeStandard}
cfg.Gateway.Scheduling.LoadBatchEnabled = true
svc := &GatewayService{
accountRepo: repo,
cache: cache,
cfg: cfg,
concurrencyService: concSvc,
}
result, err := svc.SelectAccountWithLoadAwareness(ctx, nil, "", "claude-3-5-sonnet-20241022", nil, testClientID, testUserID)
require.NoError(t, err)
require.NotNil(t, result)
require.NotNil(t, result.Account)
assert.NotEqual(t, int64(0), result.Account.ID)
})
t.Run("allow_switch=false + model_unsupported returns ErrAffinityNoSwitch", func(t *testing.T) {
cache := &affinityIntegrationCache{
getAffinityAccountsFunc: func(_ context.Context, _ int64, _ int64, _ string, _ time.Duration) ([]int64, error) {
return []int64{1}, nil
},
}
repo := &mockAccountRepoForPlatform{
accounts: []Account{
{
ID: 1, Platform: PlatformAnthropic, Priority: 1,
Status: StatusActive, Schedulable: true, Concurrency: 5,
Extra: map[string]any{
"affinity_enabled": true,
"affinity_allow_switch": false,
},
// model_mapping 仅包含 claude-3-haiku → 请求 claude-3-5-sonnet 将被拒绝
Credentials: map[string]any{
"model_mapping": map[string]any{
"claude-3-haiku-20240307": "claude-3-haiku-20240307",
},
},
},
{
ID: 2, Platform: PlatformAnthropic, Priority: 1,
Status: StatusActive, Schedulable: true, Concurrency: 5,
},
},
accountsByID: map[int64]*Account{},
}
for i := range repo.accounts {
repo.accountsByID[repo.accounts[i].ID] = &repo.accounts[i]
}
concCache := &mockConcurrencyCache{acquireResults: map[int64]bool{2: true}}
concSvc := NewConcurrencyService(concCache)
cfg := &config.Config{RunMode: config.RunModeStandard}
cfg.Gateway.Scheduling.LoadBatchEnabled = true
svc := &GatewayService{
accountRepo: repo,
cache: cache,
cfg: cfg,
concurrencyService: concSvc,
}
_, err := svc.SelectAccountWithLoadAwareness(ctx, nil, "", "claude-3-5-sonnet-20241022", nil, testClientID, testUserID)
require.Error(t, err)
assert.ErrorIs(t, err, ErrAffinityNoSwitch)
})
t.Run("allow_switch=false + red_zone returns ErrAffinityNoSwitch", func(t *testing.T) {
cache := &affinityIntegrationCache{
getAffinityAccountsFunc: func(_ context.Context, _ int64, _ int64, _ string, _ time.Duration) ([]int64, error) {
return []int64{1}, nil
},
getMultiCountFunc: func(_ context.Context, _ int64, _ int64, _ int64, _ time.Duration) (int64, int64, int64, error) {
// userCount=5, clientCount=5, perUserCount=0
// 账号 affinity_base=1, affinity_buffer=0 → clientCount(5) > base(1) + buffer(0) → 红区
return 5, 5, 0, nil
},
}
repo := &mockAccountRepoForPlatform{
accounts: []Account{
{
ID: 1, Platform: PlatformAnthropic, Priority: 1,
Status: StatusActive, Schedulable: true, Concurrency: 5,
Extra: map[string]any{
"affinity_enabled": true,
"affinity_allow_switch": false,
"affinity_base": 1,
"affinity_buffer": 0, // buffer=0 → 超过 base 直接红区
},
},
{
ID: 2, Platform: PlatformAnthropic, Priority: 1,
Status: StatusActive, Schedulable: true, Concurrency: 5,
},
},
accountsByID: map[int64]*Account{},
}
for i := range repo.accounts {
repo.accountsByID[repo.accounts[i].ID] = &repo.accounts[i]
}
concCache := &mockConcurrencyCache{acquireResults: map[int64]bool{2: true}}
concSvc := NewConcurrencyService(concCache)
cfg := &config.Config{RunMode: config.RunModeStandard}
cfg.Gateway.Scheduling.LoadBatchEnabled = true
svc := &GatewayService{
accountRepo: repo,
cache: cache,
cfg: cfg,
concurrencyService: concSvc,
}
_, err := svc.SelectAccountWithLoadAwareness(ctx, nil, "", "claude-3-5-sonnet-20241022", nil, testClientID, testUserID)
require.Error(t, err)
assert.ErrorIs(t, err, ErrAffinityNoSwitch)
})
t.Run("one_allow_switch=true overrides another allow_switch=false (一票放行)", func(t *testing.T) {
// 账号 1: allow_switch=false + rate limited(不可调度)
// 账号 3: allow_switch=true + rate limited(不可调度)
// 一票放行:账号 3 允许切换 → 不阻断 → 降级到 Layer 2 选中账号 2
cache := &affinityIntegrationCache{
getAffinityAccountsFunc: func(_ context.Context, _ int64, _ int64, _ string, _ time.Duration) ([]int64, error) {
return []int64{1, 3}, nil
},
}
repo := &mockAccountRepoForPlatform{
accounts: []Account{
{
ID: 1, Platform: PlatformAnthropic, Priority: 1,
Status: StatusActive, Schedulable: true,
RateLimitResetAt: &futureTime, // rate limited
Concurrency: 5,
Extra: map[string]any{
"affinity_enabled": true,
"affinity_allow_switch": false,
},
},
{
ID: 2, Platform: PlatformAnthropic, Priority: 1,
Status: StatusActive, Schedulable: true, Concurrency: 5,
},
{
ID: 3, Platform: PlatformAnthropic, Priority: 1,
Status: StatusActive, Schedulable: true,
RateLimitResetAt: &futureTime, // rate limited
Concurrency: 5,
Extra: map[string]any{
"affinity_enabled": true,
"affinity_allow_switch": true,
},
},
},
accountsByID: map[int64]*Account{},
}
for i := range repo.accounts {
repo.accountsByID[repo.accounts[i].ID] = &repo.accounts[i]
}
concCache := &mockConcurrencyCache{acquireResults: map[int64]bool{2: true}}
concSvc := NewConcurrencyService(concCache)
cfg := &config.Config{RunMode: config.RunModeStandard}
cfg.Gateway.Scheduling.LoadBatchEnabled = true
svc := &GatewayService{
accountRepo: repo,
cache: cache,
cfg: cfg,
concurrencyService: concSvc,
}
result, err := svc.SelectAccountWithLoadAwareness(ctx, nil, "", "claude-3-5-sonnet-20241022", nil, testClientID, testUserID)
require.NoError(t, err)
require.NotNil(t, result)
assert.Equal(t, int64(2), result.Account.ID, "一票放行: should fall through to Layer 2")
})
t.Run("excluded affinity account with allow_switch=false returns ErrAffinityNoSwitch", func(t *testing.T) {
cache := &affinityIntegrationCache{
getAffinityAccountsFunc: func(_ context.Context, _ int64, _ int64, _ string, _ time.Duration) ([]int64, error) {
return []int64{1}, nil
},
}
repo := &mockAccountRepoForPlatform{
accounts: []Account{
{
ID: 1, Platform: PlatformAnthropic, Priority: 1,
Status: StatusActive, Schedulable: true, Concurrency: 5,
Extra: map[string]any{
"affinity_enabled": true,
"affinity_allow_switch": false,
},
},
{
ID: 2, Platform: PlatformAnthropic, Priority: 1,
Status: StatusActive, Schedulable: true, Concurrency: 5,
},
},
accountsByID: map[int64]*Account{},
}
for i := range repo.accounts {
repo.accountsByID[repo.accounts[i].ID] = &repo.accounts[i]
}
concCache := &mockConcurrencyCache{acquireResults: map[int64]bool{2: true}}
concSvc := NewConcurrencyService(concCache)
cfg := &config.Config{RunMode: config.RunModeStandard}
cfg.Gateway.Scheduling.LoadBatchEnabled = true
svc := &GatewayService{
accountRepo: repo,
cache: cache,
cfg: cfg,
concurrencyService: concSvc,
}
excluded := map[int64]struct{}{1: {}}
_, err := svc.SelectAccountWithLoadAwareness(ctx, nil, "", "claude-3-5-sonnet-20241022", excluded, testClientID, testUserID)
require.Error(t, err)
assert.ErrorIs(t, err, ErrAffinityNoSwitch)
})
t.Run("disabled affinity record does not suppress sticky fallback", func(t *testing.T) {
sessionHash := "sticky-disabled-affinity"
cache := &affinityIntegrationCache{
getAffinityAccountsFunc: func(_ context.Context, _ int64, _ int64, _ string, _ time.Duration) ([]int64, error) {
return []int64{1}, nil
},
sessionBindings: map[string]int64{sessionHash: 2},
}
repo := &mockAccountRepoForPlatform{
accounts: []Account{
{
ID: 1, Platform: PlatformAnthropic, Priority: 1,
Status: StatusActive, Schedulable: true, Concurrency: 5,
Extra: map[string]any{
"affinity_enabled": false,
},
},
{
ID: 2, Platform: PlatformAnthropic, Priority: 1,
Status: StatusActive, Schedulable: true, Concurrency: 5,
},
},
accountsByID: map[int64]*Account{},
}
for i := range repo.accounts {
repo.accountsByID[repo.accounts[i].ID] = &repo.accounts[i]
}
concCache := &mockConcurrencyCache{acquireResults: map[int64]bool{2: true}}
concSvc := NewConcurrencyService(concCache)
cfg := &config.Config{RunMode: config.RunModeStandard}
cfg.Gateway.Scheduling.LoadBatchEnabled = true
svc := &GatewayService{
accountRepo: repo,
cache: cache,
cfg: cfg,
concurrencyService: concSvc,
}
result, err := svc.SelectAccountWithLoadAwareness(ctx, nil, sessionHash, "claude-3-5-sonnet-20241022", nil, testClientID, testUserID)
require.NoError(t, err)
require.NotNil(t, result)
require.NotNil(t, result.Account)
assert.Equal(t, int64(2), result.Account.ID)
})
t.Run("historical affinity record with disabled account still falls back to sticky account", func(t *testing.T) {
sessionHash := "sticky-disabled-status-affinity"
cache := &affinityIntegrationCache{
getAffinityAccountsFunc: func(_ context.Context, _ int64, _ int64, _ string, _ time.Duration) ([]int64, error) {
return []int64{1}, nil
},
sessionBindings: map[string]int64{sessionHash: 2},
}
repo := &mockAccountRepoForPlatform{
accounts: []Account{
{
ID: 1, Platform: PlatformAnthropic, Priority: 1,
Status: StatusDisabled, Schedulable: true, Concurrency: 5,
Extra: map[string]any{
"affinity_enabled": true,
},
},
{
ID: 2, Platform: PlatformAnthropic, Priority: 1,
Status: StatusActive, Schedulable: true, Concurrency: 5,
},
},
accountsByID: map[int64]*Account{},
}
for i := range repo.accounts {
repo.accountsByID[repo.accounts[i].ID] = &repo.accounts[i]
}
concCache := &mockConcurrencyCache{acquireResults: map[int64]bool{2: true}}
concSvc := NewConcurrencyService(concCache)
cfg := &config.Config{RunMode: config.RunModeStandard}
cfg.Gateway.Scheduling.LoadBatchEnabled = true
svc := &GatewayService{
accountRepo: repo,
cache: cache,
cfg: cfg,
concurrencyService: concSvc,
}
result, err := svc.SelectAccountWithLoadAwareness(ctx, nil, sessionHash, "claude-3-5-sonnet-20241022", nil, testClientID, testUserID)
require.NoError(t, err)
require.NotNil(t, result)
require.NotNil(t, result.Account)
assert.Equal(t, int64(2), result.Account.ID)
})
}
// ===========================================================================
// TestAffinityMultiDimClassify — 验证 classifyByAffinityZone 与多维度计数
// ===========================================================================
func TestAffinityMultiDimClassify(t *testing.T) {
t.Run("multi-dim zone classification with user and client dimensions", func(t *testing.T) {
makeAWL := func(id int64, extra map[string]any, count int64) accountWithLoad {
return accountWithLoad{
account: &Account{ID: id, Platform: PlatformAnthropic, Extra: extra},
loadInfo: &AccountLoadInfo{AccountID: id},
affinityCount: count,
}
}
// Account 1: client green (3 <= 5), classified as green by old classifyByAffinityZone
// Account 2: client red (10 > 8), classified as red
accs := []accountWithLoad{
makeAWL(1, map[string]any{
"affinity_enabled": true,
"affinity_base": 5,
"affinity_buffer": 3,
}, 3),
makeAWL(2, map[string]any{
"affinity_enabled": true,
"affinity_base": 5,
"affinity_buffer": 3,
}, 10),
}
result := classifyByAffinityZone(accs)
require.Len(t, result, 1)
assert.Equal(t, int64(1), result[0].account.ID, "only green account should remain")
})
t.Run("all green returns all", func(t *testing.T) {
makeAWL := func(id int64, count int64) accountWithLoad {
return accountWithLoad{
account: &Account{
ID: id,
Platform: PlatformAnthropic,
Extra: map[string]any{
"affinity_enabled": true,
"affinity_base": 10,
"affinity_buffer": 5,
},
},
loadInfo: &AccountLoadInfo{AccountID: id},
affinityCount: count,
}
}
accs := []accountWithLoad{
makeAWL(1, 3),
makeAWL(2, 5),
makeAWL(3, 10), // exactly at base
}
result := classifyByAffinityZone(accs)
require.Len(t, result, 3)
})
}