513 lines
19 KiB
Go
513 lines
19 KiB
Go
package dice
|
|
|
|
import (
|
|
"context"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
walletv1 "hyapp.local/api/proto/wallet/v1"
|
|
"hyapp/pkg/xerr"
|
|
dicedomain "hyapp/services/game-service/internal/domain/dice"
|
|
gamedomain "hyapp/services/game-service/internal/domain/game"
|
|
)
|
|
|
|
func TestRollMatchDebitsRollsAndPaysWinner(t *testing.T) {
|
|
repo := newFakeDiceRepository()
|
|
wallet := &fakeDiceWallet{balances: map[int64]int64{101: 1000, 202: 1000}}
|
|
svc := New(Config{FeeBPS: 500}, repo, wallet)
|
|
svc.now = func() time.Time { return time.UnixMilli(1700000000000) }
|
|
rolls := []int{5, 0}
|
|
svc.randomInt = func(max int) (int, error) {
|
|
if len(rolls) == 0 {
|
|
t.Fatal("randomInt called too many times")
|
|
}
|
|
value := rolls[0]
|
|
rolls = rolls[1:]
|
|
return value, nil
|
|
}
|
|
|
|
created, _, err := svc.CreateMatch(context.Background(), CreateMatchCommand{
|
|
AppCode: "lalu",
|
|
RequestID: "req-create",
|
|
UserID: 101,
|
|
GameID: "dice",
|
|
RoomID: "room_1",
|
|
RegionID: 100,
|
|
StakeCoin: 100,
|
|
MinPlayers: 2,
|
|
MaxPlayers: 3,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("CreateMatch failed: %v", err)
|
|
}
|
|
if _, _, err := svc.JoinMatch(context.Background(), JoinMatchCommand{AppCode: "lalu", RequestID: "req-join", UserID: 202, MatchID: created.MatchID}); err != nil {
|
|
t.Fatalf("JoinMatch failed: %v", err)
|
|
}
|
|
|
|
settled, _, err := svc.RollMatch(context.Background(), RollMatchCommand{AppCode: "lalu", RequestID: "req-roll", UserID: 101, MatchID: created.MatchID})
|
|
if err != nil {
|
|
t.Fatalf("RollMatch failed: %v", err)
|
|
}
|
|
if settled.Status != dicedomain.MatchStatusSettled || settled.Result != dicedomain.ParticipantResultWin {
|
|
t.Fatalf("match not settled as win: %+v", settled)
|
|
}
|
|
if len(settled.Participants) != 2 {
|
|
t.Fatalf("participants len = %d", len(settled.Participants))
|
|
}
|
|
winner := participantByUser(settled.Participants, 101)
|
|
loser := participantByUser(settled.Participants, 202)
|
|
if len(winner.DicePoints) != 1 || winner.DicePoints[0] != 6 {
|
|
t.Fatalf("winner should have one dice point, got %+v", winner.DicePoints)
|
|
}
|
|
if len(loser.DicePoints) != 1 || loser.DicePoints[0] != 1 {
|
|
t.Fatalf("loser should have one dice point, got %+v", loser.DicePoints)
|
|
}
|
|
if winner.Result != dicedomain.ParticipantResultWin || winner.PayoutCoin != 188 || winner.BalanceAfter != 1088 {
|
|
t.Fatalf("winner settlement mismatch: %+v", winner)
|
|
}
|
|
if loser.Result != dicedomain.ParticipantResultLose || loser.PayoutCoin != 0 || loser.BalanceAfter != 900 {
|
|
t.Fatalf("loser settlement mismatch: %+v", loser)
|
|
}
|
|
if wallet.calls != 3 {
|
|
t.Fatalf("wallet calls = %d, want 3", wallet.calls)
|
|
}
|
|
if repo.levelDebitOrders != 2 {
|
|
t.Fatalf("debit orders should still feed game order success path, got %d", repo.levelDebitOrders)
|
|
}
|
|
}
|
|
|
|
func TestRollMatchRequiresMinimumParticipantsBeforeWalletDebit(t *testing.T) {
|
|
repo := newFakeDiceRepository()
|
|
wallet := &fakeDiceWallet{balances: map[int64]int64{101: 1000}}
|
|
svc := New(Config{}, repo, wallet)
|
|
svc.now = func() time.Time { return time.UnixMilli(1700000000000) }
|
|
|
|
created, _, err := svc.CreateMatch(context.Background(), CreateMatchCommand{
|
|
AppCode: "lalu",
|
|
RequestID: "req-create",
|
|
UserID: 101,
|
|
GameID: "dice",
|
|
StakeCoin: 100,
|
|
MinPlayers: 2,
|
|
MaxPlayers: 3,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("CreateMatch failed: %v", err)
|
|
}
|
|
_, _, err = svc.RollMatch(context.Background(), RollMatchCommand{AppCode: "lalu", RequestID: "req-roll", UserID: 101, MatchID: created.MatchID})
|
|
if !xerr.IsCode(err, xerr.Conflict) {
|
|
t.Fatalf("RollMatch should reject not enough participants, got %v", err)
|
|
}
|
|
if wallet.calls != 0 {
|
|
t.Fatalf("wallet should not be called, got %d", wallet.calls)
|
|
}
|
|
}
|
|
|
|
func TestRollMatchDrawRerollsUntilWinner(t *testing.T) {
|
|
repo := newFakeDiceRepository()
|
|
wallet := &fakeDiceWallet{balances: map[int64]int64{101: 1000, 202: 1000}}
|
|
svc := New(Config{FeeBPS: 500}, repo, wallet)
|
|
svc.now = func() time.Time { return time.UnixMilli(1700000000000) }
|
|
rolls := []int{2, 2, 5, 0}
|
|
svc.randomInt = func(max int) (int, error) {
|
|
if len(rolls) == 0 {
|
|
t.Fatal("randomInt called too many times")
|
|
}
|
|
value := rolls[0]
|
|
rolls = rolls[1:]
|
|
return value, nil
|
|
}
|
|
|
|
created, _, err := svc.CreateMatch(context.Background(), CreateMatchCommand{
|
|
AppCode: "lalu",
|
|
RequestID: "req-create",
|
|
UserID: 101,
|
|
GameID: "dice",
|
|
StakeCoin: 100,
|
|
MinPlayers: 2,
|
|
MaxPlayers: 2,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("CreateMatch failed: %v", err)
|
|
}
|
|
if _, _, err := svc.JoinMatch(context.Background(), JoinMatchCommand{AppCode: "lalu", RequestID: "req-join", UserID: 202, MatchID: created.MatchID}); err != nil {
|
|
t.Fatalf("JoinMatch failed: %v", err)
|
|
}
|
|
|
|
draw, _, err := svc.RollMatch(context.Background(), RollMatchCommand{AppCode: "lalu", RequestID: "req-roll-1", UserID: 101, MatchID: created.MatchID})
|
|
if err != nil {
|
|
t.Fatalf("first RollMatch failed: %v", err)
|
|
}
|
|
if draw.Status != dicedomain.MatchStatusReady || draw.Result != dicedomain.ParticipantResultDraw || draw.RoundNo != 2 {
|
|
t.Fatalf("draw should keep match ready for reroll: %+v", draw)
|
|
}
|
|
if wallet.calls != 2 {
|
|
t.Fatalf("draw should only debit both users, wallet calls = %d", wallet.calls)
|
|
}
|
|
for _, participant := range draw.Participants {
|
|
if participant.Result != dicedomain.ParticipantResultDraw || participant.PayoutCoin != 0 || len(participant.DicePoints) != 1 || participant.DicePoints[0] != 3 {
|
|
t.Fatalf("draw participant mismatch: %+v", participant)
|
|
}
|
|
}
|
|
|
|
settled, _, err := svc.RollMatch(context.Background(), RollMatchCommand{AppCode: "lalu", RequestID: "req-roll-2", UserID: 101, MatchID: created.MatchID})
|
|
if err != nil {
|
|
t.Fatalf("second RollMatch failed: %v", err)
|
|
}
|
|
if settled.Status != dicedomain.MatchStatusSettled || settled.Result != dicedomain.ParticipantResultWin {
|
|
t.Fatalf("reroll should settle with winner: %+v", settled)
|
|
}
|
|
if wallet.calls != 3 {
|
|
t.Fatalf("reroll should not debit again and should only pay winner, wallet calls = %d", wallet.calls)
|
|
}
|
|
winner := participantByUser(settled.Participants, 101)
|
|
loser := participantByUser(settled.Participants, 202)
|
|
if winner.DicePoints[0] != 6 || winner.PayoutCoin != 188 || winner.BalanceAfter != 1088 {
|
|
t.Fatalf("winner after reroll mismatch: %+v", winner)
|
|
}
|
|
if loser.DicePoints[0] != 1 || loser.PayoutCoin != 0 || loser.BalanceAfter != 900 {
|
|
t.Fatalf("loser after reroll mismatch: %+v", loser)
|
|
}
|
|
}
|
|
|
|
type fakeDiceRepository struct {
|
|
game gamedomain.LaunchableGame
|
|
match dicedomain.Match
|
|
config dicedomain.Config
|
|
poolBalance int64
|
|
orders map[string]gamedomain.GameOrder
|
|
levelDebitOrders int
|
|
}
|
|
|
|
func newFakeDiceRepository() *fakeDiceRepository {
|
|
return &fakeDiceRepository{
|
|
game: gamedomain.LaunchableGame{
|
|
CatalogItem: gamedomain.CatalogItem{
|
|
AppCode: "lalu",
|
|
GameID: "dice",
|
|
PlatformCode: "dice",
|
|
ProviderGameID: "dice",
|
|
GameName: "Dice",
|
|
Status: gamedomain.StatusActive,
|
|
},
|
|
PlatformStatus: gamedomain.StatusActive,
|
|
},
|
|
config: dicedomain.Config{
|
|
AppCode: "lalu",
|
|
GameID: "dice",
|
|
Status: dicedomain.ConfigStatusActive,
|
|
StakeOptions: dicedomain.NormalizeStakeOptions(nil),
|
|
FeeBPS: int32(dicedomain.DefaultFeeBPS),
|
|
PoolBPS: int32(dicedomain.DefaultPoolBPS),
|
|
MinPlayers: dicedomain.DefaultMinPlayers,
|
|
MaxPlayers: dicedomain.DefaultMaxPlayers,
|
|
RobotEnabled: true,
|
|
RobotMatchWaitMS: dicedomain.DefaultRobotWaitMS,
|
|
},
|
|
orders: map[string]gamedomain.GameOrder{},
|
|
}
|
|
}
|
|
|
|
func (r *fakeDiceRepository) GetLaunchableGame(context.Context, string, string) (gamedomain.LaunchableGame, error) {
|
|
return r.game, nil
|
|
}
|
|
|
|
func (r *fakeDiceRepository) CreateGameOrder(_ context.Context, order gamedomain.GameOrder) (gamedomain.GameOrder, bool, error) {
|
|
if existing, ok := r.orders[order.OrderID]; ok {
|
|
if existing.RequestHash != order.RequestHash {
|
|
return gamedomain.GameOrder{}, true, xerr.New(xerr.IdempotencyConflict, "provider order payload conflict")
|
|
}
|
|
return existing, true, nil
|
|
}
|
|
r.orders[order.OrderID] = order
|
|
return order, false, nil
|
|
}
|
|
|
|
func (r *fakeDiceRepository) MarkOrderSucceeded(_ context.Context, _ string, orderID string, walletTransactionID string, balanceAfter int64, nowMs int64) error {
|
|
order := r.orders[orderID]
|
|
order.Status = gamedomain.OrderStatusSucceeded
|
|
order.WalletTransactionID = walletTransactionID
|
|
order.WalletBalanceAfter = balanceAfter
|
|
order.UpdatedAtMS = nowMs
|
|
r.orders[orderID] = order
|
|
if order.OpType == "debit" {
|
|
r.levelDebitOrders++
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (r *fakeDiceRepository) MarkOrderFailed(_ context.Context, _ string, orderID string, status string, code string, message string, nowMs int64) error {
|
|
order := r.orders[orderID]
|
|
order.Status = status
|
|
order.FailureCode = code
|
|
order.FailureMessage = message
|
|
order.UpdatedAtMS = nowMs
|
|
r.orders[orderID] = order
|
|
return nil
|
|
}
|
|
|
|
func (r *fakeDiceRepository) CreateDiceMatch(_ context.Context, match dicedomain.Match) (dicedomain.Match, error) {
|
|
r.match = cloneDiceMatch(match)
|
|
return cloneDiceMatch(r.match), nil
|
|
}
|
|
|
|
func (r *fakeDiceRepository) JoinDiceMatch(_ context.Context, _ string, _ string, userID int64, nowMs int64) (dicedomain.Match, error) {
|
|
for _, participant := range r.match.Participants {
|
|
if participant.UserID == userID {
|
|
return cloneDiceMatch(r.match), nil
|
|
}
|
|
}
|
|
seatNo := int32(len(r.match.Participants) + 1)
|
|
r.match.Participants = append(r.match.Participants, dicedomain.Participant{
|
|
AppCode: r.match.AppCode,
|
|
MatchID: r.match.MatchID,
|
|
UserID: userID,
|
|
SeatNo: seatNo,
|
|
Status: dicedomain.ParticipantStatusJoined,
|
|
StakeCoin: r.match.StakeCoin,
|
|
JoinedAtMS: nowMs,
|
|
UpdatedAtMS: nowMs,
|
|
})
|
|
r.match.CurrentPlayers = int32(len(r.match.Participants))
|
|
r.match.Status = dicedomain.MatchStatusJoining
|
|
r.match.UpdatedAtMS = nowMs
|
|
return cloneDiceMatch(r.match), nil
|
|
}
|
|
|
|
func (r *fakeDiceRepository) GetDiceMatch(context.Context, string, string) (dicedomain.Match, error) {
|
|
return cloneDiceMatch(r.match), nil
|
|
}
|
|
|
|
func (r *fakeDiceRepository) ClaimDiceMatchForRoll(_ context.Context, _ string, _ string, userID int64, nowMs int64) (dicedomain.Match, error) {
|
|
if !hasFakeDiceParticipant(r.match.Participants, userID) {
|
|
return dicedomain.Match{}, xerr.New(xerr.PermissionDenied, "dice participant is required")
|
|
}
|
|
if len(r.match.Participants) < int(r.match.MinPlayers) {
|
|
return dicedomain.Match{}, xerr.New(xerr.Conflict, "dice match does not have enough participants")
|
|
}
|
|
if r.match.Result == dicedomain.ParticipantResultDraw {
|
|
r.match.Result = ""
|
|
for index := range r.match.Participants {
|
|
r.match.Participants[index].DicePoints = nil
|
|
r.match.Participants[index].Result = ""
|
|
r.match.Participants[index].PayoutCoin = 0
|
|
r.match.Participants[index].UpdatedAtMS = nowMs
|
|
}
|
|
}
|
|
r.match.Status = dicedomain.MatchStatusSettling
|
|
r.match.UpdatedAtMS = nowMs
|
|
return cloneDiceMatch(r.match), nil
|
|
}
|
|
|
|
func (r *fakeDiceRepository) SaveDiceRolls(_ context.Context, match dicedomain.Match, nowMs int64) (dicedomain.Match, error) {
|
|
for _, source := range match.Participants {
|
|
for index := range r.match.Participants {
|
|
if r.match.Participants[index].UserID == source.UserID {
|
|
r.match.Participants[index].DicePoints = append([]int32(nil), source.DicePoints...)
|
|
r.match.Participants[index].Result = source.Result
|
|
r.match.Participants[index].PayoutCoin = source.PayoutCoin
|
|
r.match.Participants[index].UpdatedAtMS = nowMs
|
|
}
|
|
}
|
|
}
|
|
r.match.Status = dicedomain.MatchStatusPayoutApplying
|
|
r.match.Result = match.Result
|
|
r.match.UpdatedAtMS = nowMs
|
|
return cloneDiceMatch(r.match), nil
|
|
}
|
|
|
|
func (r *fakeDiceRepository) SaveDiceDrawForReroll(_ context.Context, match dicedomain.Match, nowMs int64) (dicedomain.Match, error) {
|
|
for _, source := range match.Participants {
|
|
for index := range r.match.Participants {
|
|
if r.match.Participants[index].UserID == source.UserID {
|
|
r.match.Participants[index].DicePoints = append([]int32(nil), source.DicePoints...)
|
|
r.match.Participants[index].Result = dicedomain.ParticipantResultDraw
|
|
r.match.Participants[index].PayoutCoin = 0
|
|
r.match.Participants[index].UpdatedAtMS = nowMs
|
|
}
|
|
}
|
|
}
|
|
r.match.Status = dicedomain.MatchStatusReady
|
|
r.match.Result = dicedomain.ParticipantResultDraw
|
|
r.match.RoundNo++
|
|
r.match.UpdatedAtMS = nowMs
|
|
return cloneDiceMatch(r.match), nil
|
|
}
|
|
|
|
func (r *fakeDiceRepository) MarkDiceParticipantDebitSucceeded(_ context.Context, _ string, _ string, userID int64, orderID string, balanceAfter int64, nowMs int64) error {
|
|
return r.updateParticipant(userID, func(participant *dicedomain.Participant) {
|
|
participant.Status = dicedomain.ParticipantStatusDebitSucceeded
|
|
participant.DebitOrderID = orderID
|
|
participant.BalanceAfter = balanceAfter
|
|
participant.UpdatedAtMS = nowMs
|
|
})
|
|
}
|
|
|
|
func (r *fakeDiceRepository) MarkDiceParticipantDebitFailed(_ context.Context, _ string, _ string, userID int64, orderID string, nowMs int64) error {
|
|
return r.updateParticipant(userID, func(participant *dicedomain.Participant) {
|
|
participant.Status = dicedomain.ParticipantStatusDebitFailed
|
|
participant.DebitOrderID = orderID
|
|
participant.UpdatedAtMS = nowMs
|
|
})
|
|
}
|
|
|
|
func (r *fakeDiceRepository) MarkDiceParticipantPayoutSucceeded(_ context.Context, _ string, _ string, userID int64, orderID string, balanceAfter int64, nowMs int64) error {
|
|
return r.updateParticipant(userID, func(participant *dicedomain.Participant) {
|
|
participant.Status = dicedomain.ParticipantStatusPayoutSucceeded
|
|
participant.PayoutOrderID = orderID
|
|
participant.BalanceAfter = balanceAfter
|
|
participant.UpdatedAtMS = nowMs
|
|
})
|
|
}
|
|
|
|
func (r *fakeDiceRepository) MarkDiceParticipantRefundSucceeded(_ context.Context, _ string, _ string, userID int64, orderID string, balanceAfter int64, nowMs int64) error {
|
|
return r.updateParticipant(userID, func(participant *dicedomain.Participant) {
|
|
participant.Status = dicedomain.ParticipantStatusRefundSucceeded
|
|
participant.RefundOrderID = orderID
|
|
participant.BalanceAfter = balanceAfter
|
|
participant.UpdatedAtMS = nowMs
|
|
})
|
|
}
|
|
|
|
func (r *fakeDiceRepository) MarkDiceMatchSettled(_ context.Context, _ string, _ string, result string, nowMs int64) error {
|
|
r.match.Status = dicedomain.MatchStatusSettled
|
|
r.match.Result = result
|
|
r.match.UpdatedAtMS = nowMs
|
|
r.match.SettledAtMS = nowMs
|
|
for index := range r.match.Participants {
|
|
r.match.Participants[index].Status = dicedomain.ParticipantStatusSettled
|
|
r.match.Participants[index].UpdatedAtMS = nowMs
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (r *fakeDiceRepository) MarkDiceMatchFailed(_ context.Context, _ string, _ string, result string, nowMs int64) error {
|
|
r.match.Status = dicedomain.MatchStatusFailed
|
|
r.match.Result = result
|
|
r.match.UpdatedAtMS = nowMs
|
|
return nil
|
|
}
|
|
|
|
func (r *fakeDiceRepository) GetDiceConfig(context.Context, string, string) (dicedomain.Config, error) {
|
|
return r.config, nil
|
|
}
|
|
|
|
func (r *fakeDiceRepository) ListSelfGameConfigs(context.Context, string) ([]dicedomain.Config, error) {
|
|
return []dicedomain.Config{r.config}, nil
|
|
}
|
|
|
|
func (r *fakeDiceRepository) UpsertDiceConfig(_ context.Context, config dicedomain.Config, _ int64) (dicedomain.Config, error) {
|
|
r.config = config
|
|
return config, nil
|
|
}
|
|
|
|
func (r *fakeDiceRepository) FindAndJoinWaitingDiceMatch(context.Context, string, string, int64, int64, int64) (dicedomain.Match, error) {
|
|
return dicedomain.Match{}, xerr.New(xerr.NotFound, "waiting dice match not found")
|
|
}
|
|
|
|
func (r *fakeDiceRepository) JoinDiceRobot(context.Context, string, string, int64, string, int64) (dicedomain.Match, error) {
|
|
return dicedomain.Match{}, xerr.New(xerr.NotFound, "dice robot not found")
|
|
}
|
|
|
|
func (r *fakeDiceRepository) CancelDiceMatch(context.Context, string, string, int64, int64) (dicedomain.Match, error) {
|
|
r.match.Status = dicedomain.MatchStatusCanceled
|
|
return cloneDiceMatch(r.match), nil
|
|
}
|
|
|
|
func (r *fakeDiceRepository) PickActiveDiceRobot(context.Context, string, string, string) (dicedomain.Robot, error) {
|
|
return dicedomain.Robot{}, xerr.New(xerr.NotFound, "dice robot not found")
|
|
}
|
|
|
|
func (r *fakeDiceRepository) AdjustDicePool(_ context.Context, adjustment dicedomain.PoolAdjustment) (dicedomain.PoolAdjustment, error) {
|
|
if adjustment.Direction == dicedomain.PoolDirectionOut {
|
|
r.poolBalance -= adjustment.AmountCoin
|
|
} else {
|
|
r.poolBalance += adjustment.AmountCoin
|
|
}
|
|
adjustment.BalanceAfter = r.poolBalance
|
|
return adjustment, nil
|
|
}
|
|
|
|
func (r *fakeDiceRepository) ListDiceRobots(context.Context, string, string, string, int32, string) ([]dicedomain.Robot, string, error) {
|
|
return nil, "", nil
|
|
}
|
|
|
|
func (r *fakeDiceRepository) RegisterDiceRobots(context.Context, string, string, []int64, int64, int64) ([]dicedomain.Robot, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func (r *fakeDiceRepository) SetDiceRobotStatus(context.Context, string, string, int64, string, int64) (dicedomain.Robot, error) {
|
|
return dicedomain.Robot{}, nil
|
|
}
|
|
|
|
func (r *fakeDiceRepository) DeleteDiceRobot(context.Context, string, string, int64) error {
|
|
return nil
|
|
}
|
|
|
|
func (r *fakeDiceRepository) updateParticipant(userID int64, apply func(*dicedomain.Participant)) error {
|
|
for index := range r.match.Participants {
|
|
if r.match.Participants[index].UserID == userID {
|
|
apply(&r.match.Participants[index])
|
|
return nil
|
|
}
|
|
}
|
|
return xerr.New(xerr.NotFound, "dice participant not found")
|
|
}
|
|
|
|
type fakeDiceWallet struct {
|
|
balances map[int64]int64
|
|
calls int
|
|
}
|
|
|
|
func (w *fakeDiceWallet) ApplyGameCoinChange(_ context.Context, req *walletv1.ApplyGameCoinChangeRequest) (*walletv1.ApplyGameCoinChangeResponse, error) {
|
|
w.calls++
|
|
if req.GetCoinAmount() <= 0 {
|
|
return nil, xerr.New(xerr.InvalidArgument, "coin_amount must be positive")
|
|
}
|
|
switch req.GetOpType() {
|
|
case "debit":
|
|
if w.balances[req.GetUserId()] < req.GetCoinAmount() {
|
|
return nil, xerr.New(xerr.InsufficientBalance, "insufficient balance")
|
|
}
|
|
w.balances[req.GetUserId()] -= req.GetCoinAmount()
|
|
case "credit", "refund":
|
|
w.balances[req.GetUserId()] += req.GetCoinAmount()
|
|
default:
|
|
return nil, xerr.New(xerr.InvalidArgument, "game op_type is invalid")
|
|
}
|
|
return &walletv1.ApplyGameCoinChangeResponse{
|
|
WalletTransactionId: "wtx_" + strings.ReplaceAll(req.GetProviderOrderId(), ":", "_"),
|
|
BalanceAfter: w.balances[req.GetUserId()],
|
|
}, nil
|
|
}
|
|
|
|
func (w *fakeDiceWallet) GetBalances(_ context.Context, req *walletv1.GetBalancesRequest) (*walletv1.GetBalancesResponse, error) {
|
|
return &walletv1.GetBalancesResponse{Balances: []*walletv1.AssetBalance{{
|
|
AssetType: "COIN",
|
|
AvailableAmount: w.balances[req.GetUserId()],
|
|
}}}, nil
|
|
}
|
|
|
|
func participantByUser(participants []dicedomain.Participant, userID int64) dicedomain.Participant {
|
|
for _, participant := range participants {
|
|
if participant.UserID == userID {
|
|
return participant
|
|
}
|
|
}
|
|
return dicedomain.Participant{}
|
|
}
|
|
|
|
func hasFakeDiceParticipant(participants []dicedomain.Participant, userID int64) bool {
|
|
return participantByUser(participants, userID).UserID == userID
|
|
}
|
|
|
|
func cloneDiceMatch(match dicedomain.Match) dicedomain.Match {
|
|
cloned := match
|
|
cloned.Participants = append([]dicedomain.Participant(nil), match.Participants...)
|
|
for index := range cloned.Participants {
|
|
cloned.Participants[index].DicePoints = append([]int32(nil), match.Participants[index].DicePoints...)
|
|
}
|
|
return cloned
|
|
}
|