297 lines
12 KiB
Go
297 lines
12 KiB
Go
package luckygift
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"testing"
|
|
"time"
|
|
|
|
"hyapp-admin-server/internal/integration/luckygiftadmin"
|
|
"hyapp-admin-server/internal/middleware"
|
|
luckygiftv1 "hyapp.local/api/proto/luckygift/v1"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/status"
|
|
)
|
|
|
|
type poolAdjustmentClientStub struct {
|
|
luckygiftadmin.Client
|
|
request *luckygiftv1.AdjustLuckyGiftPoolBalanceRequest
|
|
response *luckygiftv1.AdjustLuckyGiftPoolBalanceResponse
|
|
err error
|
|
}
|
|
|
|
func (s *poolAdjustmentClientStub) AdjustLuckyGiftPoolBalance(_ context.Context, request *luckygiftv1.AdjustLuckyGiftPoolBalanceRequest) (*luckygiftv1.AdjustLuckyGiftPoolBalanceResponse, error) {
|
|
s.request = request
|
|
return s.response, s.err
|
|
}
|
|
|
|
func TestConfigToProtoConvertsBusinessUnitsToPPM(t *testing.T) {
|
|
config := configToProto(configRequest{
|
|
PoolID: " lucky_100 ",
|
|
Enabled: true,
|
|
TargetRTPPercent: 95,
|
|
PoolRatePercent: 96,
|
|
SettlementWindowWager: 1_000_000,
|
|
ControlBandPercent: 1,
|
|
GiftPriceReference: 100,
|
|
NoviceMaxEquivalentDraws: 2_000,
|
|
NormalMaxEquivalentDraws: 20_000,
|
|
Stages: []stageDTO{
|
|
{
|
|
Stage: " novice ",
|
|
Tiers: []tierDTO{
|
|
{
|
|
TierID: " novice_0_3x ",
|
|
Multiplier: 0.3,
|
|
ProbabilityPercent: 22,
|
|
Enabled: true,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
})
|
|
|
|
if config.GetPoolId() != "lucky_100" {
|
|
t.Fatalf("pool id = %q, want lucky_100", config.GetPoolId())
|
|
}
|
|
if config.GetTargetRtpPpm() != 950_000 {
|
|
t.Fatalf("target rtp ppm = %d, want 950000", config.GetTargetRtpPpm())
|
|
}
|
|
if config.GetPoolRatePpm() != 960_000 {
|
|
t.Fatalf("pool rate ppm = %d, want 960000", config.GetPoolRatePpm())
|
|
}
|
|
if config.GetControlBandPpm() != 10_000 {
|
|
t.Fatalf("control band ppm = %d, want 10000", config.GetControlBandPpm())
|
|
}
|
|
if config.GetNoviceMaxEquivalentDraws() != 2_000 || config.GetNormalMaxEquivalentDraws() != 20_000 {
|
|
t.Fatalf("equivalent draw thresholds mismatch: novice=%d normal=%d", config.GetNoviceMaxEquivalentDraws(), config.GetNormalMaxEquivalentDraws())
|
|
}
|
|
tier := config.GetStages()[0].GetTiers()[0]
|
|
if tier.GetStage() != "novice" {
|
|
t.Fatalf("tier stage = %q, want novice", tier.GetStage())
|
|
}
|
|
if tier.GetTierId() != "novice_0_3x" {
|
|
t.Fatalf("tier id = %q, want novice_0_3x", tier.GetTierId())
|
|
}
|
|
if tier.GetMultiplierPpm() != 300_000 {
|
|
t.Fatalf("multiplier ppm = %d, want 300000", tier.GetMultiplierPpm())
|
|
}
|
|
if tier.GetBaseWeightPpm() != 220_000 {
|
|
t.Fatalf("base weight ppm = %d, want 220000", tier.GetBaseWeightPpm())
|
|
}
|
|
}
|
|
|
|
func TestCreditLuckyGiftPoolBalanceForwardsAuditedOwnerCommand(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
client := &poolAdjustmentClientStub{response: &luckygiftv1.AdjustLuckyGiftPoolBalanceResponse{
|
|
Adjustment: &luckygiftv1.LuckyGiftPoolAdjustment{
|
|
AdjustmentId: "adjustment-1", AppCode: "aslan", PoolId: "lucky", StrategyVersion: "dynamic_v3",
|
|
Direction: "in", AmountCoins: 100, Reason: "launch budget", OperatorAdminId: 7, BalanceBefore: 0, BalanceAfter: 100,
|
|
},
|
|
Pool: &luckygiftv1.LuckyGiftPoolBalance{
|
|
AppCode: "aslan", PoolId: "lucky", StrategyVersion: "dynamic_v3", Balance: 100,
|
|
ManualCreditTotal: 100, Materialized: true,
|
|
},
|
|
}}
|
|
recorder := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(recorder)
|
|
c.Request = httptest.NewRequest(http.MethodPost, "/admin/ops-center/lucky-gifts/pools/credit?app_code=aslan&pool_id=lucky&strategy_version=dynamic_v3", bytes.NewBufferString(`{"adjustment_id":"adjustment-1","amount_coins":100,"reason":"launch budget"}`))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
c.Set(middleware.ContextUserID, uint(7))
|
|
c.Set(middleware.ContextRequestID, "request-1")
|
|
New(client, time.Second, nil).CreditLuckyGiftPoolBalance(c)
|
|
if recorder.Code != http.StatusOK {
|
|
t.Fatalf("status=%d body=%s", recorder.Code, recorder.Body.String())
|
|
}
|
|
if client.request == nil || client.request.GetDirection() != "in" || client.request.GetOperatorAdminId() != 7 ||
|
|
client.request.GetMeta().GetAppCode() != "aslan" || client.request.GetMeta().GetRequestId() != "request-1" {
|
|
t.Fatalf("owner request=%+v", client.request)
|
|
}
|
|
var envelope struct {
|
|
Code int `json:"code"`
|
|
Data struct {
|
|
Pool struct {
|
|
StrategyVersion string `json:"strategy_version"`
|
|
ManualCreditTotal int64 `json:"manual_credit_total"`
|
|
} `json:"pool"`
|
|
} `json:"data"`
|
|
}
|
|
if err := json.Unmarshal(recorder.Body.Bytes(), &envelope); err != nil {
|
|
t.Fatalf("decode response: %v", err)
|
|
}
|
|
if envelope.Code != 0 || envelope.Data.Pool.StrategyVersion != "dynamic_v3" || envelope.Data.Pool.ManualCreditTotal != 100 {
|
|
t.Fatalf("response=%s", recorder.Body.String())
|
|
}
|
|
}
|
|
|
|
func TestDebitLuckyGiftPoolBalanceMapsOwnerConflictToHTTP409(t *testing.T) {
|
|
gin.SetMode(gin.TestMode)
|
|
client := &poolAdjustmentClientStub{err: status.Error(codes.FailedPrecondition, "debit would cross reserve floor")}
|
|
recorder := httptest.NewRecorder()
|
|
c, _ := gin.CreateTestContext(recorder)
|
|
c.Request = httptest.NewRequest(http.MethodPost, "/admin/ops-center/lucky-gifts/pools/debit?app_code=aslan&pool_id=lucky&strategy_version=dynamic_v3", bytes.NewBufferString(`{"adjustment_id":"adjustment-2","amount_coins":101,"reason":"return budget"}`))
|
|
c.Request.Header.Set("Content-Type", "application/json")
|
|
c.Set(middleware.ContextUserID, uint(7))
|
|
New(client, time.Second, nil).DebitLuckyGiftPoolBalance(c)
|
|
if recorder.Code != http.StatusConflict {
|
|
t.Fatalf("status=%d want=409 body=%s", recorder.Code, recorder.Body.String())
|
|
}
|
|
}
|
|
|
|
func TestConfigToProtoGeneratesUniqueTierIDs(t *testing.T) {
|
|
config := configToProto(configRequest{
|
|
PoolID: "lucky",
|
|
Stages: []stageDTO{
|
|
{
|
|
Stage: "advanced",
|
|
Tiers: []tierDTO{
|
|
{TierID: "manual_one", Multiplier: 0, ProbabilityPercent: 50, Enabled: true},
|
|
{TierID: "manual_two", Multiplier: 5, ProbabilityPercent: 25, Enabled: true},
|
|
{TierID: "manual_two", Multiplier: 5, ProbabilityPercent: 25, Enabled: true},
|
|
{TierID: "manual_decimal", Multiplier: 0.5, ProbabilityPercent: 0},
|
|
},
|
|
},
|
|
},
|
|
})
|
|
|
|
tiers := config.GetStages()[0].GetTiers()
|
|
got := []string{tiers[0].GetTierId(), tiers[1].GetTierId(), tiers[2].GetTierId(), tiers[3].GetTierId()}
|
|
want := []string{"advanced_none", "advanced_5x", "advanced_5x_2", "advanced_0_5x"}
|
|
for index := range want {
|
|
if got[index] != want[index] {
|
|
t.Fatalf("tier id[%d] = %q, want %q; all=%v", index, got[index], want[index], got)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestConfigFromProtoConvertsPPMToBusinessUnits(t *testing.T) {
|
|
config := configFromProto(&luckygiftv1.LuckyGiftRuleConfig{
|
|
AppCode: "hyapp",
|
|
PoolId: "lucky_100",
|
|
RuleVersion: 7,
|
|
Enabled: true,
|
|
TargetRtpPpm: 950_000,
|
|
PoolRatePpm: 960_000,
|
|
SettlementWindowWager: 1_000_000,
|
|
ControlBandPpm: 10_000,
|
|
GiftPriceReference: 100,
|
|
NoviceMaxEquivalentDraws: 2_000,
|
|
NormalMaxEquivalentDraws: 20_000,
|
|
CreatedByAdminId: 12,
|
|
CreatedAtMs: 1_700_000_000_000,
|
|
Stages: []*luckygiftv1.LuckyGiftRuleStage{
|
|
{
|
|
Stage: "novice",
|
|
Tiers: []*luckygiftv1.LuckyGiftRuleTier{
|
|
{
|
|
TierId: "novice_0_3x",
|
|
MultiplierPpm: 300_000,
|
|
BaseWeightPpm: 220_000,
|
|
Enabled: true,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
})
|
|
|
|
if config.TargetRTPPercent != 95 {
|
|
t.Fatalf("target rtp percent = %v, want 95", config.TargetRTPPercent)
|
|
}
|
|
if config.PoolRatePercent != 96 {
|
|
t.Fatalf("pool rate percent = %v, want 96", config.PoolRatePercent)
|
|
}
|
|
if config.ControlBandPercent != 1 {
|
|
t.Fatalf("control band percent = %v, want 1", config.ControlBandPercent)
|
|
}
|
|
if config.NoviceMaxEquivalentDraws != 2_000 || config.NormalMaxEquivalentDraws != 20_000 {
|
|
t.Fatalf("equivalent draw thresholds were not copied from proto: novice=%d normal=%d", config.NoviceMaxEquivalentDraws, config.NormalMaxEquivalentDraws)
|
|
}
|
|
if config.Stages[0].Tiers[0].Multiplier != 0.3 {
|
|
t.Fatalf("multiplier = %v, want 0.3", config.Stages[0].Tiers[0].Multiplier)
|
|
}
|
|
if config.Stages[0].Tiers[0].ProbabilityPercent != 22 {
|
|
t.Fatalf("probability percent = %v, want 22", config.Stages[0].Tiers[0].ProbabilityPercent)
|
|
}
|
|
}
|
|
|
|
func TestDynamicConfigAdminMappingRoundTrip(t *testing.T) {
|
|
protoConfig := configToProto(configRequest{
|
|
AppCode: " LALU ",
|
|
PoolID: " lucky ",
|
|
StrategyVersion: " DYNAMIC_V3 ",
|
|
Enabled: true,
|
|
TargetRTPPercent: 98,
|
|
PoolRatePercent: 98,
|
|
ProfitRatePercent: 1,
|
|
AnchorRatePercent: 1,
|
|
SettlementWindowWager: 1_000_000,
|
|
ControlBandPercent: 3,
|
|
GiftPriceReference: 100,
|
|
InitialPoolCoins: 1_000_000,
|
|
LossStreakGuarantee: 5,
|
|
LowWatermarkCoins: 10_000_000,
|
|
LowWaterNonzeroFactorPercent: 70,
|
|
HighWatermarkCoins: 20_000_000,
|
|
HighWaterNonzeroFactorPercent: 130,
|
|
RechargeBoostWindowMS: 300_000,
|
|
RechargeBoostFactorPercent: 110,
|
|
JackpotMultipliers: []float64{200, 500, 1000},
|
|
JackpotGlobalRTPMaxPercent: 98,
|
|
JackpotUserDayRTPMaxPercent: 96,
|
|
JackpotUser72hRTPMaxPercent: 96,
|
|
JackpotSpendThresholdCoins: 5_000,
|
|
MaxJackpotHitsPerUserDay: 5,
|
|
MaxSinglePayout: 10_000,
|
|
UserHourlyPayoutCap: 20_000,
|
|
UserDailyPayoutCap: 30_000,
|
|
DeviceDailyPayoutCap: 40_000,
|
|
RoomHourlyPayoutCap: 50_000,
|
|
AnchorDailyPayoutCap: 60_000,
|
|
Stages: []stageDTO{{
|
|
Stage: " normal ",
|
|
MinRecharge7DCoins: 7_000,
|
|
MinRecharge30DCoins: 30_000,
|
|
Tiers: []tierDTO{{Multiplier: 1, ProbabilityPercent: 100, Enabled: true}},
|
|
}},
|
|
})
|
|
|
|
if protoConfig.GetStrategyVersion() != "dynamic_v3" || protoConfig.GetProfitRatePpm() != 10_000 || protoConfig.GetAnchorRatePpm() != 10_000 {
|
|
t.Fatalf("strategy/fund split proto mismatch: %+v", protoConfig)
|
|
}
|
|
if protoConfig.GetInitialPoolCoins() != 0 {
|
|
t.Fatalf("dynamic_v3 legacy initial pool was forwarded: %d", protoConfig.GetInitialPoolCoins())
|
|
}
|
|
if protoConfig.GetLowWaterNonzeroFactorPpm() != 700_000 || protoConfig.GetHighWaterNonzeroFactorPpm() != 1_300_000 || protoConfig.GetRechargeBoostFactorPpm() != 1_100_000 {
|
|
t.Fatalf("dynamic factors lost precision in admin mapping: %+v", protoConfig)
|
|
}
|
|
if got := protoConfig.GetJackpotMultiplierPpms(); len(got) != 3 || got[0] != 200_000_000 || got[2] != 1_000_000_000 {
|
|
t.Fatalf("jackpot multiplier ppms=%v, want 200x/500x/1000x", got)
|
|
}
|
|
stage := protoConfig.GetStages()[0]
|
|
if stage.GetMinRecharge_7DCoins() != 7_000 || stage.GetMinRecharge_30DCoins() != 30_000 {
|
|
t.Fatalf("stage recharge thresholds were not mapped: %+v", stage)
|
|
}
|
|
|
|
dto := configFromProto(protoConfig)
|
|
if dto.StrategyVersion != "dynamic_v3" || dto.ProfitRatePercent != 1 || dto.AnchorRatePercent != 1 {
|
|
t.Fatalf("strategy/fund split DTO mismatch: %+v", dto)
|
|
}
|
|
if dto.InitialPoolCoins != 0 {
|
|
t.Fatalf("dynamic_v3 DTO exposed legacy initial pool: %d", dto.InitialPoolCoins)
|
|
}
|
|
if dto.LowWaterNonzeroFactorPercent != 70 || dto.HighWaterNonzeroFactorPercent != 130 || dto.RechargeBoostFactorPercent != 110 {
|
|
t.Fatalf("dynamic factor DTO mismatch: %+v", dto)
|
|
}
|
|
if len(dto.JackpotMultipliers) != 3 || dto.JackpotMultipliers[1] != 500 || dto.JackpotUser72hRTPMaxPercent != 96 {
|
|
t.Fatalf("jackpot DTO mismatch: %+v", dto)
|
|
}
|
|
if dto.MaxSinglePayout != 10_000 || dto.AnchorDailyPayoutCap != 60_000 || dto.Stages[0].MinRecharge30DCoins != 30_000 {
|
|
t.Fatalf("risk/stage DTO mismatch: %+v", dto)
|
|
}
|
|
}
|