mirror of
https://github.com/Wei-Shaw/sub2api.git
synced 2026-10-07 16:37:52 +08:00
557 lines
20 KiB
Go
557 lines
20 KiB
Go
//go:build unit
|
|
|
|
package service
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"math"
|
|
"strconv"
|
|
"testing"
|
|
|
|
"github.com/Wei-Shaw/sub2api/internal/config"
|
|
"github.com/Wei-Shaw/sub2api/internal/pkg/antigravity"
|
|
infraerrors "github.com/Wei-Shaw/sub2api/internal/pkg/errors"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
type settingUpdateRepoStub struct {
|
|
updates map[string]string
|
|
}
|
|
|
|
func (s *settingUpdateRepoStub) Get(ctx context.Context, key string) (*Setting, error) {
|
|
panic("unexpected Get call")
|
|
}
|
|
|
|
func (s *settingUpdateRepoStub) GetValue(ctx context.Context, key string) (string, error) {
|
|
panic("unexpected GetValue call")
|
|
}
|
|
|
|
func (s *settingUpdateRepoStub) Set(ctx context.Context, key, value string) error {
|
|
panic("unexpected Set call")
|
|
}
|
|
|
|
func (s *settingUpdateRepoStub) GetMultiple(ctx context.Context, keys []string) (map[string]string, error) {
|
|
panic("unexpected GetMultiple call")
|
|
}
|
|
|
|
func (s *settingUpdateRepoStub) SetMultiple(ctx context.Context, settings map[string]string) error {
|
|
s.updates = make(map[string]string, len(settings))
|
|
for k, v := range settings {
|
|
s.updates[k] = v
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *settingUpdateRepoStub) GetAll(ctx context.Context) (map[string]string, error) {
|
|
panic("unexpected GetAll call")
|
|
}
|
|
|
|
func (s *settingUpdateRepoStub) Delete(ctx context.Context, key string) error {
|
|
panic("unexpected Delete call")
|
|
}
|
|
|
|
type settingGetAllRepoStub struct {
|
|
values map[string]string
|
|
}
|
|
|
|
func (s *settingGetAllRepoStub) Get(ctx context.Context, key string) (*Setting, error) {
|
|
panic("unexpected Get call")
|
|
}
|
|
|
|
func (s *settingGetAllRepoStub) GetValue(ctx context.Context, key string) (string, error) {
|
|
panic("unexpected GetValue call")
|
|
}
|
|
|
|
func (s *settingGetAllRepoStub) Set(ctx context.Context, key, value string) error {
|
|
panic("unexpected Set call")
|
|
}
|
|
|
|
func (s *settingGetAllRepoStub) GetMultiple(ctx context.Context, keys []string) (map[string]string, error) {
|
|
panic("unexpected GetMultiple call")
|
|
}
|
|
|
|
func (s *settingGetAllRepoStub) SetMultiple(ctx context.Context, settings map[string]string) error {
|
|
panic("unexpected SetMultiple call")
|
|
}
|
|
|
|
func (s *settingGetAllRepoStub) GetAll(ctx context.Context) (map[string]string, error) {
|
|
out := make(map[string]string, len(s.values))
|
|
for key, value := range s.values {
|
|
out[key] = value
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (s *settingGetAllRepoStub) Delete(ctx context.Context, key string) error {
|
|
panic("unexpected Delete call")
|
|
}
|
|
|
|
type settingAntigravityUARepoStub struct {
|
|
values map[string]string
|
|
}
|
|
|
|
func (s *settingAntigravityUARepoStub) Get(ctx context.Context, key string) (*Setting, error) {
|
|
panic("unexpected Get call")
|
|
}
|
|
|
|
func (s *settingAntigravityUARepoStub) GetValue(ctx context.Context, key string) (string, error) {
|
|
if value, ok := s.values[key]; ok {
|
|
return value, nil
|
|
}
|
|
return "", ErrSettingNotFound
|
|
}
|
|
|
|
func (s *settingAntigravityUARepoStub) Set(ctx context.Context, key, value string) error {
|
|
panic("unexpected Set call")
|
|
}
|
|
|
|
func (s *settingAntigravityUARepoStub) GetMultiple(ctx context.Context, keys []string) (map[string]string, error) {
|
|
panic("unexpected GetMultiple call")
|
|
}
|
|
|
|
func (s *settingAntigravityUARepoStub) SetMultiple(ctx context.Context, settings map[string]string) error {
|
|
panic("unexpected SetMultiple call")
|
|
}
|
|
|
|
func (s *settingAntigravityUARepoStub) GetAll(ctx context.Context) (map[string]string, error) {
|
|
panic("unexpected GetAll call")
|
|
}
|
|
|
|
func (s *settingAntigravityUARepoStub) Delete(ctx context.Context, key string) error {
|
|
panic("unexpected Delete call")
|
|
}
|
|
|
|
type defaultSubGroupReaderStub struct {
|
|
byID map[int64]*Group
|
|
errBy map[int64]error
|
|
calls []int64
|
|
}
|
|
|
|
func TestSettingService_AffiliateAdminRechargeSetting(t *testing.T) {
|
|
t.Run("missing value defaults to disabled", func(t *testing.T) {
|
|
svc := NewSettingService(&settingGetAllRepoStub{values: map[string]string{}}, &config.Config{})
|
|
|
|
settings, err := svc.GetAllSettings(context.Background())
|
|
require.NoError(t, err)
|
|
require.False(t, settings.AdminRechargeRebateEnabled)
|
|
})
|
|
|
|
t.Run("explicit value is parsed", func(t *testing.T) {
|
|
svc := NewSettingService(&settingGetAllRepoStub{values: map[string]string{
|
|
SettingKeyAffiliateAdminRechargeEnabled: "true",
|
|
}}, &config.Config{})
|
|
|
|
settings, err := svc.GetAllSettings(context.Background())
|
|
require.NoError(t, err)
|
|
require.True(t, settings.AdminRechargeRebateEnabled)
|
|
})
|
|
|
|
t.Run("value is persisted", func(t *testing.T) {
|
|
repo := &settingUpdateRepoStub{}
|
|
svc := NewSettingService(repo, &config.Config{})
|
|
|
|
err := svc.UpdateSettings(context.Background(), &SystemSettings{
|
|
AdminRechargeRebateEnabled: true,
|
|
})
|
|
require.NoError(t, err)
|
|
require.Equal(t, "true", repo.updates[SettingKeyAffiliateAdminRechargeEnabled])
|
|
})
|
|
}
|
|
|
|
func (s *defaultSubGroupReaderStub) GetByID(ctx context.Context, id int64) (*Group, error) {
|
|
s.calls = append(s.calls, id)
|
|
if err, ok := s.errBy[id]; ok {
|
|
return nil, err
|
|
}
|
|
if g, ok := s.byID[id]; ok {
|
|
return g, nil
|
|
}
|
|
return nil, ErrGroupNotFound
|
|
}
|
|
|
|
func TestSettingService_UpdateSettings_DefaultSubscriptions_ValidGroup(t *testing.T) {
|
|
repo := &settingUpdateRepoStub{}
|
|
groupReader := &defaultSubGroupReaderStub{
|
|
byID: map[int64]*Group{
|
|
11: {ID: 11, SubscriptionType: SubscriptionTypeSubscription},
|
|
},
|
|
}
|
|
svc := NewSettingService(repo, &config.Config{})
|
|
svc.SetDefaultSubscriptionGroupReader(groupReader)
|
|
|
|
err := svc.UpdateSettings(context.Background(), &SystemSettings{
|
|
DefaultSubscriptions: []DefaultSubscriptionSetting{
|
|
{GroupID: 11, ValidityDays: 30},
|
|
},
|
|
})
|
|
require.NoError(t, err)
|
|
require.Equal(t, []int64{11}, groupReader.calls)
|
|
|
|
raw, ok := repo.updates[SettingKeyDefaultSubscriptions]
|
|
require.True(t, ok)
|
|
|
|
var got []DefaultSubscriptionSetting
|
|
require.NoError(t, json.Unmarshal([]byte(raw), &got))
|
|
require.Equal(t, []DefaultSubscriptionSetting{
|
|
{GroupID: 11, ValidityDays: 30},
|
|
}, got)
|
|
}
|
|
|
|
func TestSettingService_UpdateSettings_DefaultSubscriptions_RejectsNonSubscriptionGroup(t *testing.T) {
|
|
repo := &settingUpdateRepoStub{}
|
|
groupReader := &defaultSubGroupReaderStub{
|
|
byID: map[int64]*Group{
|
|
12: {ID: 12, SubscriptionType: SubscriptionTypeStandard},
|
|
},
|
|
}
|
|
svc := NewSettingService(repo, &config.Config{})
|
|
svc.SetDefaultSubscriptionGroupReader(groupReader)
|
|
|
|
err := svc.UpdateSettings(context.Background(), &SystemSettings{
|
|
DefaultSubscriptions: []DefaultSubscriptionSetting{
|
|
{GroupID: 12, ValidityDays: 7},
|
|
},
|
|
})
|
|
require.Error(t, err)
|
|
require.Equal(t, "DEFAULT_SUBSCRIPTION_GROUP_INVALID", infraerrors.Reason(err))
|
|
require.Nil(t, repo.updates)
|
|
}
|
|
|
|
func TestSettingService_UpdateSettings_DefaultSubscriptions_RejectsNotFoundGroup(t *testing.T) {
|
|
repo := &settingUpdateRepoStub{}
|
|
groupReader := &defaultSubGroupReaderStub{
|
|
errBy: map[int64]error{
|
|
13: ErrGroupNotFound,
|
|
},
|
|
}
|
|
svc := NewSettingService(repo, &config.Config{})
|
|
svc.SetDefaultSubscriptionGroupReader(groupReader)
|
|
|
|
err := svc.UpdateSettings(context.Background(), &SystemSettings{
|
|
DefaultSubscriptions: []DefaultSubscriptionSetting{
|
|
{GroupID: 13, ValidityDays: 7},
|
|
},
|
|
})
|
|
require.Error(t, err)
|
|
require.Equal(t, "DEFAULT_SUBSCRIPTION_GROUP_INVALID", infraerrors.Reason(err))
|
|
require.Equal(t, "13", infraerrors.FromError(err).Metadata["group_id"])
|
|
require.Nil(t, repo.updates)
|
|
}
|
|
|
|
func TestSettingService_UpdateSettings_DefaultSubscriptions_RejectsDuplicateGroup(t *testing.T) {
|
|
repo := &settingUpdateRepoStub{}
|
|
groupReader := &defaultSubGroupReaderStub{
|
|
byID: map[int64]*Group{
|
|
11: {ID: 11, SubscriptionType: SubscriptionTypeSubscription},
|
|
},
|
|
}
|
|
svc := NewSettingService(repo, &config.Config{})
|
|
svc.SetDefaultSubscriptionGroupReader(groupReader)
|
|
|
|
err := svc.UpdateSettings(context.Background(), &SystemSettings{
|
|
DefaultSubscriptions: []DefaultSubscriptionSetting{
|
|
{GroupID: 11, ValidityDays: 30},
|
|
{GroupID: 11, ValidityDays: 60},
|
|
},
|
|
})
|
|
require.Error(t, err)
|
|
require.Equal(t, "DEFAULT_SUBSCRIPTION_GROUP_DUPLICATE", infraerrors.Reason(err))
|
|
require.Equal(t, "11", infraerrors.FromError(err).Metadata["group_id"])
|
|
require.Nil(t, repo.updates)
|
|
}
|
|
|
|
func TestSettingService_UpdateSettings_DefaultSubscriptions_RejectsDuplicateGroupWithoutGroupReader(t *testing.T) {
|
|
repo := &settingUpdateRepoStub{}
|
|
svc := NewSettingService(repo, &config.Config{})
|
|
|
|
err := svc.UpdateSettings(context.Background(), &SystemSettings{
|
|
DefaultSubscriptions: []DefaultSubscriptionSetting{
|
|
{GroupID: 11, ValidityDays: 30},
|
|
{GroupID: 11, ValidityDays: 60},
|
|
},
|
|
})
|
|
require.Error(t, err)
|
|
require.Equal(t, "DEFAULT_SUBSCRIPTION_GROUP_DUPLICATE", infraerrors.Reason(err))
|
|
require.Equal(t, "11", infraerrors.FromError(err).Metadata["group_id"])
|
|
require.Nil(t, repo.updates)
|
|
}
|
|
|
|
func TestSettingService_UpdateSettings_RegistrationEmailSuffixWhitelist_Normalized(t *testing.T) {
|
|
repo := &settingUpdateRepoStub{}
|
|
svc := NewSettingService(repo, &config.Config{})
|
|
|
|
err := svc.UpdateSettings(context.Background(), &SystemSettings{
|
|
RegistrationEmailSuffixWhitelist: []string{"example.com", "@EXAMPLE.com", " @foo.bar ", "*.EDU.CN"},
|
|
})
|
|
require.NoError(t, err)
|
|
require.Equal(t, `["@example.com","@foo.bar","*.edu.cn"]`, repo.updates[SettingKeyRegistrationEmailSuffixWhitelist])
|
|
}
|
|
|
|
func TestSettingService_UpdateSettings_RegistrationEmailSuffixWhitelist_Invalid(t *testing.T) {
|
|
repo := &settingUpdateRepoStub{}
|
|
svc := NewSettingService(repo, &config.Config{})
|
|
|
|
err := svc.UpdateSettings(context.Background(), &SystemSettings{
|
|
RegistrationEmailSuffixWhitelist: []string{"@invalid_domain"},
|
|
})
|
|
require.Error(t, err)
|
|
require.Equal(t, "INVALID_REGISTRATION_EMAIL_SUFFIX_WHITELIST", infraerrors.Reason(err))
|
|
}
|
|
|
|
func TestParseDefaultSubscriptions_NormalizesValues(t *testing.T) {
|
|
got := parseDefaultSubscriptions(`[{"group_id":11,"validity_days":30},{"group_id":11,"validity_days":60},{"group_id":0,"validity_days":10},{"group_id":12,"validity_days":99999}]`)
|
|
require.Equal(t, []DefaultSubscriptionSetting{
|
|
{GroupID: 11, ValidityDays: 30},
|
|
{GroupID: 11, ValidityDays: 60},
|
|
{GroupID: 12, ValidityDays: MaxValidityDays},
|
|
}, got)
|
|
}
|
|
|
|
func TestSettingService_UpdateSettings_TablePreferences(t *testing.T) {
|
|
repo := &settingUpdateRepoStub{}
|
|
svc := NewSettingService(repo, &config.Config{})
|
|
|
|
err := svc.UpdateSettings(context.Background(), &SystemSettings{
|
|
TableDefaultPageSize: 50,
|
|
TablePageSizeOptions: []int{20, 50, 100},
|
|
})
|
|
require.NoError(t, err)
|
|
require.Equal(t, "50", repo.updates[SettingKeyTableDefaultPageSize])
|
|
require.Equal(t, "[20,50,100]", repo.updates[SettingKeyTablePageSizeOptions])
|
|
|
|
err = svc.UpdateSettings(context.Background(), &SystemSettings{
|
|
TableDefaultPageSize: 1000,
|
|
TablePageSizeOptions: []int{20, 100},
|
|
})
|
|
require.NoError(t, err)
|
|
require.Equal(t, "1000", repo.updates[SettingKeyTableDefaultPageSize])
|
|
require.Equal(t, "[20,100]", repo.updates[SettingKeyTablePageSizeOptions])
|
|
}
|
|
|
|
func TestSettingService_UpdateSettings_PaymentVisibleMethodsAndAdvancedScheduler(t *testing.T) {
|
|
resetOpenAIAdvancedSchedulerSettingCacheForTest()
|
|
defer resetOpenAIAdvancedSchedulerSettingCacheForTest()
|
|
|
|
repo := &settingUpdateRepoStub{}
|
|
svc := NewSettingService(repo, &config.Config{})
|
|
|
|
err := svc.UpdateSettings(context.Background(), &SystemSettings{
|
|
PaymentVisibleMethodAlipaySource: "alipay",
|
|
PaymentVisibleMethodWxpaySource: "easypay",
|
|
PaymentVisibleMethodAlipayEnabled: true,
|
|
PaymentVisibleMethodWxpayEnabled: false,
|
|
OpenAILowUpstreamRatePriorityEnabled: true,
|
|
OpenAIOAuthSchedulingRateMultiplier: 0.05,
|
|
OpenAIAdvancedSchedulerEnabled: true,
|
|
OpenAIAdvancedSchedulerStickyWeightedEnabled: true,
|
|
OpenAIAdvancedSchedulerSubscriptionPriorityEnabled: true,
|
|
OpenAIAdvancedSchedulerLBTopK: " 3 ",
|
|
OpenAIAdvancedSchedulerWeightPriority: "2.50",
|
|
OpenAIAdvancedSchedulerWeightLoad: "0",
|
|
OpenAIAdvancedSchedulerWeightQueue: "0.75",
|
|
OpenAIAdvancedSchedulerWeightErrorRate: "1.25",
|
|
OpenAIAdvancedSchedulerWeightTTFT: "0.5",
|
|
OpenAIAdvancedSchedulerWeightReset: "",
|
|
OpenAIAdvancedSchedulerWeightQuotaHeadroom: "0.2",
|
|
OpenAIAdvancedSchedulerWeightUpstreamCost: "1.5",
|
|
OpenAIAdvancedSchedulerWeightPreviousResponse: "8",
|
|
OpenAIAdvancedSchedulerWeightSessionSticky: "4",
|
|
})
|
|
require.NoError(t, err)
|
|
require.Equal(t, VisibleMethodSourceOfficialAlipay, repo.updates[SettingPaymentVisibleMethodAlipaySource])
|
|
require.Equal(t, VisibleMethodSourceEasyPayWechat, repo.updates[SettingPaymentVisibleMethodWxpaySource])
|
|
require.Equal(t, "true", repo.updates[SettingPaymentVisibleMethodAlipayEnabled])
|
|
require.Equal(t, "false", repo.updates[SettingPaymentVisibleMethodWxpayEnabled])
|
|
require.Equal(t, "true", repo.updates[SettingKeyOpenAILowUpstreamRatePriorityEnabled])
|
|
require.Equal(t, "0.05", repo.updates[SettingKeyOpenAIOAuthSchedulingRateMultiplier])
|
|
require.Equal(t, "true", repo.updates[openAIAdvancedSchedulerSettingKey])
|
|
require.Equal(t, "true", repo.updates[SettingKeyOpenAIAdvancedSchedulerStickyWeightedEnabled])
|
|
require.Equal(t, "true", repo.updates[SettingKeyOpenAIAdvancedSchedulerSubscriptionPriorityEnabled])
|
|
require.Equal(t, "3", repo.updates[SettingKeyOpenAIAdvancedSchedulerLBTopK])
|
|
require.Equal(t, "2.5", repo.updates[SettingKeyOpenAIAdvancedSchedulerWeightPriority])
|
|
require.Equal(t, "0", repo.updates[SettingKeyOpenAIAdvancedSchedulerWeightLoad])
|
|
require.Equal(t, "0.75", repo.updates[SettingKeyOpenAIAdvancedSchedulerWeightQueue])
|
|
require.Equal(t, "1.25", repo.updates[SettingKeyOpenAIAdvancedSchedulerWeightErrorRate])
|
|
require.Equal(t, "0.5", repo.updates[SettingKeyOpenAIAdvancedSchedulerWeightTTFT])
|
|
require.Equal(t, "", repo.updates[SettingKeyOpenAIAdvancedSchedulerWeightReset])
|
|
require.Equal(t, "0.2", repo.updates[SettingKeyOpenAIAdvancedSchedulerWeightQuotaHeadroom])
|
|
require.Equal(t, "1.5", repo.updates[SettingKeyOpenAIAdvancedSchedulerWeightUpstreamCost])
|
|
require.Equal(t, "8", repo.updates[SettingKeyOpenAIAdvancedSchedulerWeightPreviousResponse])
|
|
require.Equal(t, "4", repo.updates[SettingKeyOpenAIAdvancedSchedulerWeightSessionSticky])
|
|
}
|
|
|
|
func TestSettingService_UpdateSettingsRejectsInvalidOpenAIOAuthSchedulingRateMultiplier(t *testing.T) {
|
|
repo := &settingUpdateRepoStub{}
|
|
svc := NewSettingService(repo, &config.Config{})
|
|
|
|
for _, rate := range []float64{-0.01, math.NaN(), math.Inf(1)} {
|
|
err := svc.UpdateSettings(context.Background(), &SystemSettings{OpenAIOAuthSchedulingRateMultiplier: rate})
|
|
require.Error(t, err)
|
|
}
|
|
}
|
|
|
|
func TestSettingService_UpdateSettings_OpenAIAdvancedSchedulerWeightSums(t *testing.T) {
|
|
maxFloat := strconv.FormatFloat(math.MaxFloat64, 'g', -1, 64)
|
|
tests := []struct {
|
|
name string
|
|
weights SystemSettings
|
|
wantErr bool
|
|
}{
|
|
{
|
|
name: "reset only base is valid",
|
|
weights: SystemSettings{
|
|
OpenAIAdvancedSchedulerWeightPriority: "0",
|
|
OpenAIAdvancedSchedulerWeightLoad: "0",
|
|
OpenAIAdvancedSchedulerWeightQueue: "0",
|
|
OpenAIAdvancedSchedulerWeightErrorRate: "0",
|
|
OpenAIAdvancedSchedulerWeightTTFT: "0",
|
|
OpenAIAdvancedSchedulerWeightReset: "1",
|
|
OpenAIAdvancedSchedulerWeightQuotaHeadroom: "0",
|
|
OpenAIAdvancedSchedulerWeightUpstreamCost: "0",
|
|
OpenAIAdvancedSchedulerWeightPreviousResponse: "0",
|
|
OpenAIAdvancedSchedulerWeightSessionSticky: "0",
|
|
},
|
|
},
|
|
{
|
|
name: "base sum overflow is rejected",
|
|
weights: SystemSettings{
|
|
OpenAIAdvancedSchedulerWeightPriority: maxFloat,
|
|
OpenAIAdvancedSchedulerWeightLoad: maxFloat,
|
|
},
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "sticky total sum overflow is rejected",
|
|
weights: SystemSettings{
|
|
OpenAIAdvancedSchedulerWeightPriority: maxFloat,
|
|
OpenAIAdvancedSchedulerWeightPreviousResponse: maxFloat,
|
|
},
|
|
wantErr: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
svc := NewSettingService(&settingUpdateRepoStub{}, &config.Config{})
|
|
err := svc.UpdateSettings(context.Background(), &tt.weights)
|
|
if tt.wantErr {
|
|
require.Error(t, err)
|
|
return
|
|
}
|
|
require.NoError(t, err)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSettingService_ParseSettingsDefaultsOpenAIOAuthSchedulingRateMultiplier(t *testing.T) {
|
|
svc := NewSettingService(&settingUpdateRepoStub{}, &config.Config{})
|
|
|
|
require.Equal(t, 1.0, svc.parseSettings(map[string]string{}).OpenAIOAuthSchedulingRateMultiplier)
|
|
require.Equal(t, 0.05, svc.parseSettings(map[string]string{SettingKeyOpenAIOAuthSchedulingRateMultiplier: "0.05"}).OpenAIOAuthSchedulingRateMultiplier)
|
|
}
|
|
|
|
func TestSettingService_GetAllSettings_OpenAIAdvancedSchedulerEffectiveValuesUseConfig(t *testing.T) {
|
|
cfg := &config.Config{}
|
|
cfg.Gateway.OpenAIWS.LBTopK = 13
|
|
cfg.Gateway.OpenAIWS.SchedulerScoreWeights = config.GatewayOpenAIWSSchedulerScoreWeights{
|
|
Priority: 2,
|
|
Load: 3,
|
|
Queue: 4,
|
|
ErrorRate: 5,
|
|
TTFT: 6,
|
|
Reset: 7,
|
|
QuotaHeadroom: 8,
|
|
UpstreamCost: 9,
|
|
PreviousResponse: 10,
|
|
SessionSticky: 11,
|
|
}
|
|
svc := NewSettingService(&settingGetAllRepoStub{values: map[string]string{
|
|
SettingKeyOpenAIAdvancedSchedulerLBTopK: "3",
|
|
SettingKeyOpenAIAdvancedSchedulerWeightPriority: "99",
|
|
SettingKeyOpenAIAdvancedSchedulerWeightSessionSticky: "88",
|
|
}}, cfg)
|
|
|
|
settings, err := svc.GetAllSettings(context.Background())
|
|
require.NoError(t, err)
|
|
require.Equal(t, "3", settings.OpenAIAdvancedSchedulerLBTopK)
|
|
require.Equal(t, "99", settings.OpenAIAdvancedSchedulerWeightPriority)
|
|
require.Equal(t, "88", settings.OpenAIAdvancedSchedulerWeightSessionSticky)
|
|
require.Equal(t, "13", settings.OpenAIAdvancedSchedulerEffectiveLBTopK)
|
|
require.Equal(t, "2", settings.OpenAIAdvancedSchedulerEffectiveWeightPriority)
|
|
require.Equal(t, "3", settings.OpenAIAdvancedSchedulerEffectiveWeightLoad)
|
|
require.Equal(t, "9", settings.OpenAIAdvancedSchedulerEffectiveWeightUpstreamCost)
|
|
require.Equal(t, "11", settings.OpenAIAdvancedSchedulerEffectiveWeightSessionSticky)
|
|
}
|
|
|
|
func TestSettingService_UpdateSettings_AntigravityUserAgentVersion(t *testing.T) {
|
|
repo := &settingUpdateRepoStub{}
|
|
svc := NewSettingService(repo, &config.Config{})
|
|
|
|
err := svc.UpdateSettings(context.Background(), &SystemSettings{
|
|
AntigravityUserAgentVersion: "1.23.2",
|
|
})
|
|
require.NoError(t, err)
|
|
require.Equal(t, "1.23.2", repo.updates[SettingKeyAntigravityUserAgentVersion])
|
|
}
|
|
|
|
func TestSettingService_UpdateSettings_APIKeyACLTrustForwardedIPRefreshesConfig(t *testing.T) {
|
|
repo := &settingUpdateRepoStub{}
|
|
cfg := &config.Config{}
|
|
svc := NewSettingService(repo, cfg)
|
|
|
|
err := svc.UpdateSettings(context.Background(), &SystemSettings{
|
|
APIKeyACLTrustForwardedIP: true,
|
|
})
|
|
require.NoError(t, err)
|
|
require.Equal(t, "true", repo.updates[SettingKeyAPIKeyACLTrustForwardedIP])
|
|
require.True(t, cfg.Security.TrustForwardedIPForAPIKeyACL)
|
|
require.True(t, cfg.TrustForwardedIPForAPIKeyACL())
|
|
}
|
|
|
|
func TestSettingService_ParseSettings_APIKeyACLTrustForwardedIPFallsBackToConfigWhenMissing(t *testing.T) {
|
|
cfg := &config.Config{}
|
|
cfg.Security.TrustForwardedIPForAPIKeyACL = true
|
|
svc := NewSettingService(&settingUpdateRepoStub{}, cfg)
|
|
|
|
got := svc.parseSettings(map[string]string{})
|
|
|
|
require.True(t, got.APIKeyACLTrustForwardedIP)
|
|
}
|
|
|
|
func TestSettingService_GetAntigravityUserAgentVersion_Precedence(t *testing.T) {
|
|
t.Run("后台设置优先", func(t *testing.T) {
|
|
svc := NewSettingService(&settingAntigravityUARepoStub{values: map[string]string{
|
|
SettingKeyAntigravityUserAgentVersion: "1.24.0",
|
|
}}, &config.Config{})
|
|
|
|
require.Equal(t, "1.24.0", svc.GetAntigravityUserAgentVersion(context.Background()))
|
|
})
|
|
|
|
t.Run("空值回退配置默认值", func(t *testing.T) {
|
|
svc := NewSettingService(&settingAntigravityUARepoStub{values: map[string]string{
|
|
SettingKeyAntigravityUserAgentVersion: "",
|
|
}}, &config.Config{})
|
|
|
|
require.Equal(t, antigravity.GetDefaultUserAgentVersion(), svc.GetAntigravityUserAgentVersion(context.Background()))
|
|
})
|
|
|
|
t.Run("缺失回退配置默认值", func(t *testing.T) {
|
|
svc := NewSettingService(&settingAntigravityUARepoStub{values: map[string]string{}}, &config.Config{})
|
|
|
|
require.Equal(t, antigravity.GetDefaultUserAgentVersion(), svc.GetAntigravityUserAgentVersion(context.Background()))
|
|
})
|
|
}
|
|
|
|
func TestSettingService_UpdateSettings_RejectsInvalidPaymentVisibleMethodSource(t *testing.T) {
|
|
repo := &settingUpdateRepoStub{}
|
|
svc := NewSettingService(repo, &config.Config{})
|
|
|
|
err := svc.UpdateSettings(context.Background(), &SystemSettings{
|
|
PaymentVisibleMethodAlipaySource: "not-a-provider",
|
|
})
|
|
require.Error(t, err)
|
|
require.Equal(t, "INVALID_PAYMENT_VISIBLE_METHOD_SOURCE", infraerrors.Reason(err))
|
|
require.Nil(t, repo.updates)
|
|
}
|