432 lines
16 KiB
Go
432 lines
16 KiB
Go
package roomturnoverreward
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"testing"
|
|
"time"
|
|
|
|
"google.golang.org/grpc"
|
|
"google.golang.org/protobuf/proto"
|
|
roomeventsv1 "hyapp.local/api/proto/events/room/v1"
|
|
roomv1 "hyapp.local/api/proto/room/v1"
|
|
walletv1 "hyapp.local/api/proto/wallet/v1"
|
|
"hyapp/pkg/appcode"
|
|
domain "hyapp/services/activity-service/internal/domain/roomturnoverreward"
|
|
messageservice "hyapp/services/activity-service/internal/service/message"
|
|
)
|
|
|
|
func TestWeekWindowUsesUTCOneMondayBoundary(t *testing.T) {
|
|
cases := []struct {
|
|
name string
|
|
now string
|
|
wantStart string
|
|
wantEnd string
|
|
}{
|
|
{
|
|
name: "monday zero still belongs to previous week",
|
|
now: "2026-06-01T00:00:00Z",
|
|
wantStart: "2026-05-25T01:00:00Z",
|
|
wantEnd: "2026-06-01T01:00:00Z",
|
|
},
|
|
{
|
|
name: "monday one starts new contribution week",
|
|
now: "2026-06-01T01:00:00Z",
|
|
wantStart: "2026-06-01T01:00:00Z",
|
|
wantEnd: "2026-06-08T01:00:00Z",
|
|
},
|
|
{
|
|
name: "sunday belongs to current week",
|
|
now: "2026-06-07T23:59:59Z",
|
|
wantStart: "2026-06-01T01:00:00Z",
|
|
wantEnd: "2026-06-08T01:00:00Z",
|
|
},
|
|
{
|
|
name: "cross month keeps utc week",
|
|
now: "2026-07-01T12:30:00Z",
|
|
wantStart: "2026-06-29T01:00:00Z",
|
|
wantEnd: "2026-07-06T01:00:00Z",
|
|
},
|
|
{
|
|
name: "cross year keeps utc week",
|
|
now: "2027-01-01T08:00:00Z",
|
|
wantStart: "2026-12-28T01:00:00Z",
|
|
wantEnd: "2027-01-04T01:00:00Z",
|
|
},
|
|
}
|
|
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
now := mustParseTime(t, tc.now)
|
|
start, end := WeekWindow(now)
|
|
if got := start.Format(time.RFC3339); got != tc.wantStart {
|
|
t.Fatalf("unexpected start: got %s want %s", got, tc.wantStart)
|
|
}
|
|
if got := end.Format(time.RFC3339); got != tc.wantEnd {
|
|
t.Fatalf("unexpected end: got %s want %s", got, tc.wantEnd)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestPreviousWeekWindowReturnsCompletedUTCWeek(t *testing.T) {
|
|
start, end := PreviousWeekWindow(mustParseTime(t, "2026-06-08T01:00:00Z"))
|
|
if got := start.Format(time.RFC3339); got != "2026-06-01T01:00:00Z" {
|
|
t.Fatalf("unexpected previous start: %s", got)
|
|
}
|
|
if got := end.Format(time.RFC3339); got != "2026-06-08T01:00:00Z" {
|
|
t.Fatalf("unexpected previous end: %s", got)
|
|
}
|
|
}
|
|
|
|
func TestMatchHighestTierReturnsHighestThreshold(t *testing.T) {
|
|
tiers := []domain.Tier{
|
|
{TierID: 1, TierCode: "bronze", ThresholdCoinSpent: 100, RewardCoinAmount: 10, Status: domain.TierStatusActive},
|
|
{TierID: 2, TierCode: "silver", ThresholdCoinSpent: 500, RewardCoinAmount: 60, Status: domain.TierStatusActive},
|
|
{TierID: 3, TierCode: "gold", ThresholdCoinSpent: 1000, RewardCoinAmount: 160, Status: domain.TierStatusActive},
|
|
{TierID: 4, TierCode: "hidden", ThresholdCoinSpent: 700, RewardCoinAmount: 90, Status: domain.TierStatusInactive},
|
|
}
|
|
|
|
tier, ok := MatchHighestTier(tiers, 850)
|
|
if !ok {
|
|
t.Fatal("expected a matched tier")
|
|
}
|
|
if tier.TierCode != "silver" {
|
|
t.Fatalf("unexpected tier: got %s want silver", tier.TierCode)
|
|
}
|
|
}
|
|
|
|
func TestRetrySettlementRejectsTierNotMatchedWithoutGrantSideEffects(t *testing.T) {
|
|
repo := &retryBoundaryRepository{
|
|
settlement: domain.Settlement{
|
|
SettlementID: "settlement-tier-not-matched",
|
|
RoomID: "room-1",
|
|
Status: domain.SettlementStatusFailed,
|
|
FailureReason: "tier_not_matched",
|
|
WalletCommandID: "room_turnover_reward:lalu:1:room-1",
|
|
RewardCoinAmount: 0,
|
|
},
|
|
}
|
|
room := &retryBoundaryRoom{ownerID: 10001}
|
|
wallet := &retryBoundaryWallet{}
|
|
svc := New(repo, wallet, room)
|
|
|
|
got, err := svc.RetrySettlement(context.Background(), repo.settlement.SettlementID)
|
|
if err == nil {
|
|
t.Fatal("expected retry to reject tier_not_matched settlement")
|
|
}
|
|
if got.Status != domain.SettlementStatusFailed || got.FailureReason != "tier_not_matched" {
|
|
t.Fatalf("retry should return original failed settlement, got %+v", got)
|
|
}
|
|
if repo.resetCalls != 0 || repo.grantCalls != 0 || repo.failCalls != 0 {
|
|
t.Fatalf("tier_not_matched retry must not mutate settlement: reset=%d grant=%d fail=%d", repo.resetCalls, repo.grantCalls, repo.failCalls)
|
|
}
|
|
if room.calls != 0 {
|
|
t.Fatalf("tier_not_matched retry must not fetch room owner, calls=%d", room.calls)
|
|
}
|
|
if wallet.calls != 0 {
|
|
t.Fatalf("tier_not_matched retry must not call wallet, calls=%d", wallet.calls)
|
|
}
|
|
}
|
|
|
|
func TestHandleRoomEventConsumesGiftValueAsHeatValue(t *testing.T) {
|
|
repo := &roomGiftEventRepository{}
|
|
svc := New(repo, nil, nil)
|
|
svc.SetClock(func() time.Time { return mustParseTime(t, "2026-06-03T12:00:00Z") })
|
|
body, err := proto.Marshal(&roomeventsv1.RoomGiftSent{
|
|
GiftValue: 900,
|
|
CoinSpent: 1200,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("marshal gift: %v", err)
|
|
}
|
|
result, err := svc.HandleRoomEvent(context.Background(), &roomeventsv1.EventEnvelope{
|
|
EventId: "room-gift-heat-value",
|
|
EventType: "RoomGiftSent",
|
|
RoomId: "room-1",
|
|
AppCode: appcode.Default,
|
|
OccurredAtMs: mustParseTime(t, "2026-06-03T10:00:00Z").UnixMilli(),
|
|
Body: body,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("HandleRoomEvent returned error: %v", err)
|
|
}
|
|
if result.Status != domain.EventStatusConsumed {
|
|
t.Fatalf("unexpected result: %+v", result)
|
|
}
|
|
if repo.event.CoinSpent != 900 {
|
|
t.Fatalf("room turnover reward must consume gift_value/HeatValue, got %+v", repo.event)
|
|
}
|
|
if got := time.UnixMilli(repo.periodStartMS).UTC().Format(time.RFC3339); got != "2026-06-01T01:00:00Z" {
|
|
t.Fatalf("unexpected period start: %s", got)
|
|
}
|
|
}
|
|
|
|
func TestGrantSettlementCreatesSystemNoticeBeforeMarkGranted(t *testing.T) {
|
|
repo := &retryBoundaryRepository{
|
|
settlement: roomTurnoverRewardGrantableSettlement(),
|
|
}
|
|
wallet := &retryBoundaryWallet{}
|
|
notices := &fakeRewardNoticeService{}
|
|
svc := New(repo, wallet, nil, WithNoticeService(notices))
|
|
svc.SetClock(func() time.Time { return mustParseTime(t, "2026-06-09T01:00:00Z") })
|
|
|
|
granted, err := svc.grantSettlement(appcode.WithContext(context.Background(), "lalu"), repo.settlement)
|
|
if err != nil {
|
|
t.Fatalf("grantSettlement returned error: %v", err)
|
|
}
|
|
if wallet.calls != 1 || repo.grantCalls != 1 || repo.failCalls != 0 {
|
|
t.Fatalf("grant path mismatch: wallet=%d grant=%d fail=%d", wallet.calls, repo.grantCalls, repo.failCalls)
|
|
}
|
|
if notices.calls != 1 {
|
|
t.Fatalf("expected one system notice, got %d", notices.calls)
|
|
}
|
|
if granted.Status != domain.SettlementStatusGranted || granted.WalletTransactionID != "wallet-tx-1" {
|
|
t.Fatalf("settlement should be granted with wallet transaction, got %+v", granted)
|
|
}
|
|
|
|
cmd := notices.command
|
|
if cmd.TargetUserID != repo.settlement.OwnerUserID || cmd.Producer != rewardNoticeProducer || cmd.ProducerEventID != repo.settlement.SettlementID {
|
|
t.Fatalf("notice idempotency or target mismatch: %+v", cmd)
|
|
}
|
|
if cmd.ProducerEventType != rewardNoticeEventType || cmd.AggregateType != rewardNoticeAggregateType || cmd.AggregateID != repo.settlement.SettlementID {
|
|
t.Fatalf("notice aggregate mismatch: %+v", cmd)
|
|
}
|
|
wantSummary := "Congratulations! You earned 123 coins from this week's room turnover reward."
|
|
if cmd.Title != "Room turnover reward" || cmd.Summary != wantSummary || cmd.Body != wantSummary {
|
|
t.Fatalf("notice content mismatch: title=%q summary=%q body=%q", cmd.Title, cmd.Summary, cmd.Body)
|
|
}
|
|
if cmd.SentAtMS != 1234 {
|
|
t.Fatalf("notice sent_at_ms should use wallet grant time, got %d", cmd.SentAtMS)
|
|
}
|
|
if cmd.Metadata["settlement_id"] != repo.settlement.SettlementID ||
|
|
cmd.Metadata["room_id"] != repo.settlement.RoomID ||
|
|
cmd.Metadata["reward_coin_amount"] != repo.settlement.RewardCoinAmount ||
|
|
cmd.Metadata["wallet_transaction_id"] != "wallet-tx-1" {
|
|
t.Fatalf("notice metadata mismatch: %+v", cmd.Metadata)
|
|
}
|
|
}
|
|
|
|
func TestGrantSettlementFailsWhenSystemNoticeCannotBeCreated(t *testing.T) {
|
|
repo := &retryBoundaryRepository{
|
|
settlement: roomTurnoverRewardGrantableSettlement(),
|
|
}
|
|
wallet := &retryBoundaryWallet{}
|
|
notices := &fakeRewardNoticeService{err: errors.New("message unavailable")}
|
|
svc := New(repo, wallet, nil, WithNoticeService(notices))
|
|
|
|
if _, err := svc.grantSettlement(appcode.WithContext(context.Background(), "lalu"), repo.settlement); err == nil {
|
|
t.Fatal("expected grantSettlement to fail when notice creation fails")
|
|
}
|
|
if wallet.calls != 1 || notices.calls != 1 {
|
|
t.Fatalf("wallet should be credited once and notice attempted once, wallet=%d notices=%d", wallet.calls, notices.calls)
|
|
}
|
|
if repo.grantCalls != 0 || repo.failCalls != 1 || repo.settlement.Status != domain.SettlementStatusFailed {
|
|
t.Fatalf("notice failure must not mark granted: grant=%d fail=%d settlement=%+v", repo.grantCalls, repo.failCalls, repo.settlement)
|
|
}
|
|
}
|
|
|
|
func roomTurnoverRewardGrantableSettlement() domain.Settlement {
|
|
return domain.Settlement{
|
|
SettlementID: "settlement-room-turnover-1",
|
|
AppCode: "lalu",
|
|
RoomID: "room-1",
|
|
OwnerUserID: 42,
|
|
PeriodStartMS: mustUnixMilli("2026-06-01T01:00:00Z"),
|
|
PeriodEndMS: mustUnixMilli("2026-06-08T01:00:00Z"),
|
|
CoinSpent: 9000,
|
|
TierID: 2,
|
|
TierCode: "silver",
|
|
ThresholdCoinSpent: 5000,
|
|
RewardCoinAmount: 123,
|
|
Status: domain.SettlementStatusPending,
|
|
WalletCommandID: "room_turnover_reward:lalu:20260601:room-1",
|
|
}
|
|
}
|
|
|
|
func mustUnixMilli(value string) int64 {
|
|
parsed, err := time.Parse(time.RFC3339, value)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return parsed.UnixMilli()
|
|
}
|
|
|
|
func mustParseTime(t *testing.T, value string) time.Time {
|
|
t.Helper()
|
|
parsed, err := time.Parse(time.RFC3339, value)
|
|
if err != nil {
|
|
t.Fatalf("parse time %q: %v", value, err)
|
|
}
|
|
return parsed
|
|
}
|
|
|
|
type retryBoundaryRepository struct {
|
|
settlement domain.Settlement
|
|
resetCalls int
|
|
grantCalls int
|
|
failCalls int
|
|
}
|
|
|
|
type roomGiftEventRepository struct {
|
|
event domain.RoomGiftEvent
|
|
periodStartMS int64
|
|
periodEndMS int64
|
|
}
|
|
|
|
func (r *roomGiftEventRepository) GetRoomTurnoverRewardConfig(context.Context) (domain.Config, bool, error) {
|
|
return domain.Config{}, false, nil
|
|
}
|
|
|
|
func (r *roomGiftEventRepository) UpdateRoomTurnoverRewardConfig(context.Context, domain.Config, int64) (domain.Config, error) {
|
|
return domain.Config{}, nil
|
|
}
|
|
|
|
func (r *roomGiftEventRepository) ConsumeRoomTurnoverGiftEvent(_ context.Context, event domain.RoomGiftEvent, periodStartMS int64, periodEndMS int64, _ int64) (domain.EventResult, error) {
|
|
r.event = event
|
|
r.periodStartMS = periodStartMS
|
|
r.periodEndMS = periodEndMS
|
|
return domain.EventResult{EventID: event.EventID, Status: domain.EventStatusConsumed}, nil
|
|
}
|
|
|
|
func (r *roomGiftEventRepository) GetRoomTurnoverRewardProgress(context.Context, string, int64) (domain.Progress, bool, error) {
|
|
return domain.Progress{}, false, nil
|
|
}
|
|
|
|
func (r *roomGiftEventRepository) GetLatestRoomTurnoverRewardSettlement(context.Context, string) (domain.Settlement, bool, error) {
|
|
return domain.Settlement{}, false, nil
|
|
}
|
|
|
|
func (r *roomGiftEventRepository) ListRoomTurnoverRewardSettlements(context.Context, domain.SettlementQuery) ([]domain.Settlement, int64, error) {
|
|
return nil, 0, nil
|
|
}
|
|
|
|
func (r *roomGiftEventRepository) ListUnsettledRoomTurnoverRewardProgress(context.Context, int64, int) ([]domain.Progress, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func (r *roomGiftEventRepository) InsertRoomTurnoverRewardSettlement(context.Context, domain.Settlement, int64) (domain.Settlement, bool, error) {
|
|
return domain.Settlement{}, false, nil
|
|
}
|
|
|
|
func (r *roomGiftEventRepository) ListPendingRoomTurnoverRewardSettlements(context.Context, int) ([]domain.Settlement, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func (r *roomGiftEventRepository) GetRoomTurnoverRewardSettlement(context.Context, string) (domain.Settlement, bool, error) {
|
|
return domain.Settlement{}, false, nil
|
|
}
|
|
|
|
func (r *roomGiftEventRepository) ResetRoomTurnoverRewardSettlementForRetry(context.Context, string, int64, int64) (domain.Settlement, error) {
|
|
return domain.Settlement{}, nil
|
|
}
|
|
|
|
func (r *roomGiftEventRepository) MarkRoomTurnoverRewardSettlementGranted(context.Context, string, string, int64) (domain.Settlement, error) {
|
|
return domain.Settlement{}, nil
|
|
}
|
|
|
|
func (r *roomGiftEventRepository) MarkRoomTurnoverRewardSettlementFailed(context.Context, string, string, int64) error {
|
|
return nil
|
|
}
|
|
|
|
func (r *retryBoundaryRepository) GetRoomTurnoverRewardConfig(context.Context) (domain.Config, bool, error) {
|
|
panic("unexpected GetRoomTurnoverRewardConfig")
|
|
}
|
|
|
|
func (r *retryBoundaryRepository) UpdateRoomTurnoverRewardConfig(context.Context, domain.Config, int64) (domain.Config, error) {
|
|
panic("unexpected UpdateRoomTurnoverRewardConfig")
|
|
}
|
|
|
|
func (r *retryBoundaryRepository) ConsumeRoomTurnoverGiftEvent(context.Context, domain.RoomGiftEvent, int64, int64, int64) (domain.EventResult, error) {
|
|
panic("unexpected ConsumeRoomTurnoverGiftEvent")
|
|
}
|
|
|
|
func (r *retryBoundaryRepository) GetRoomTurnoverRewardProgress(context.Context, string, int64) (domain.Progress, bool, error) {
|
|
panic("unexpected GetRoomTurnoverRewardProgress")
|
|
}
|
|
|
|
func (r *retryBoundaryRepository) GetLatestRoomTurnoverRewardSettlement(context.Context, string) (domain.Settlement, bool, error) {
|
|
panic("unexpected GetLatestRoomTurnoverRewardSettlement")
|
|
}
|
|
|
|
func (r *retryBoundaryRepository) ListRoomTurnoverRewardSettlements(context.Context, domain.SettlementQuery) ([]domain.Settlement, int64, error) {
|
|
panic("unexpected ListRoomTurnoverRewardSettlements")
|
|
}
|
|
|
|
func (r *retryBoundaryRepository) ListUnsettledRoomTurnoverRewardProgress(context.Context, int64, int) ([]domain.Progress, error) {
|
|
panic("unexpected ListUnsettledRoomTurnoverRewardProgress")
|
|
}
|
|
|
|
func (r *retryBoundaryRepository) InsertRoomTurnoverRewardSettlement(context.Context, domain.Settlement, int64) (domain.Settlement, bool, error) {
|
|
panic("unexpected InsertRoomTurnoverRewardSettlement")
|
|
}
|
|
|
|
func (r *retryBoundaryRepository) ListPendingRoomTurnoverRewardSettlements(context.Context, int) ([]domain.Settlement, error) {
|
|
panic("unexpected ListPendingRoomTurnoverRewardSettlements")
|
|
}
|
|
|
|
func (r *retryBoundaryRepository) GetRoomTurnoverRewardSettlement(_ context.Context, settlementID string) (domain.Settlement, bool, error) {
|
|
if settlementID != r.settlement.SettlementID {
|
|
return domain.Settlement{}, false, nil
|
|
}
|
|
return r.settlement, true, nil
|
|
}
|
|
|
|
func (r *retryBoundaryRepository) ResetRoomTurnoverRewardSettlementForRetry(_ context.Context, _ string, ownerUserID int64, _ int64) (domain.Settlement, error) {
|
|
r.resetCalls++
|
|
r.settlement.Status = domain.SettlementStatusPending
|
|
r.settlement.OwnerUserID = ownerUserID
|
|
r.settlement.FailureReason = ""
|
|
return r.settlement, nil
|
|
}
|
|
|
|
func (r *retryBoundaryRepository) MarkRoomTurnoverRewardSettlementGranted(_ context.Context, _ string, walletTransactionID string, _ int64) (domain.Settlement, error) {
|
|
r.grantCalls++
|
|
r.settlement.Status = domain.SettlementStatusGranted
|
|
r.settlement.WalletTransactionID = walletTransactionID
|
|
return r.settlement, nil
|
|
}
|
|
|
|
func (r *retryBoundaryRepository) MarkRoomTurnoverRewardSettlementFailed(_ context.Context, _ string, reason string, _ int64) error {
|
|
r.failCalls++
|
|
r.settlement.Status = domain.SettlementStatusFailed
|
|
r.settlement.FailureReason = reason
|
|
return nil
|
|
}
|
|
|
|
type retryBoundaryRoom struct {
|
|
ownerID int64
|
|
calls int
|
|
}
|
|
|
|
func (r *retryBoundaryRoom) AdminGetRoom(context.Context, *roomv1.AdminGetRoomRequest, ...grpc.CallOption) (*roomv1.AdminGetRoomResponse, error) {
|
|
r.calls++
|
|
return &roomv1.AdminGetRoomResponse{Room: &roomv1.AdminRoomListItem{OwnerUserId: r.ownerID}}, nil
|
|
}
|
|
|
|
type retryBoundaryWallet struct {
|
|
calls int
|
|
req *walletv1.CreditRoomTurnoverRewardRequest
|
|
}
|
|
|
|
func (w *retryBoundaryWallet) CreditRoomTurnoverReward(_ context.Context, req *walletv1.CreditRoomTurnoverRewardRequest, _ ...grpc.CallOption) (*walletv1.CreditRoomTurnoverRewardResponse, error) {
|
|
w.calls++
|
|
w.req = req
|
|
return &walletv1.CreditRoomTurnoverRewardResponse{TransactionId: "wallet-tx-1", GrantedAtMs: 1234}, nil
|
|
}
|
|
|
|
type fakeRewardNoticeService struct {
|
|
calls int
|
|
command messageservice.NoticeCommand
|
|
err error
|
|
}
|
|
|
|
func (s *fakeRewardNoticeService) CreateSystemNotice(_ context.Context, cmd messageservice.NoticeCommand) (messageservice.NoticeResult, error) {
|
|
s.calls++
|
|
s.command = cmd
|
|
if s.err != nil {
|
|
return messageservice.NoticeResult{}, s.err
|
|
}
|
|
return messageservice.NoticeResult{Created: true}, nil
|
|
}
|