289 lines
12 KiB
Go
289 lines
12 KiB
Go
package achievement_test
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"testing"
|
|
"time"
|
|
|
|
"google.golang.org/grpc"
|
|
walletv1 "hyapp.local/api/proto/wallet/v1"
|
|
"hyapp/pkg/appcode"
|
|
domain "hyapp/services/activity-service/internal/domain/achievement"
|
|
achievementservice "hyapp/services/activity-service/internal/service/achievement"
|
|
"hyapp/services/activity-service/internal/testutil/mysqltest"
|
|
)
|
|
|
|
func TestAchievementUnlockBadgeAndRewardFlow(t *testing.T) {
|
|
svc, wallet := newAchievementService(t)
|
|
ctx := appcode.WithContext(context.Background(), "lalu")
|
|
|
|
definition, created, err := svc.UpsertAchievementDefinition(ctx, domain.DefinitionCommand{
|
|
CollectionID: domain.CollectionOrdinary,
|
|
CollectionType: domain.CollectionOrdinary,
|
|
AchievementType: domain.TypeOrdinary,
|
|
Title: "任务达人",
|
|
Status: domain.StatusActive,
|
|
PrimaryBadgeResourceID: 7001,
|
|
RewardResourceGroupID: 9001,
|
|
AutoPinPolicy: domain.AutoPinIfEmpty,
|
|
HonorVisibility: true,
|
|
OperatorAdminID: 90001,
|
|
Conditions: []domain.ConditionCommand{
|
|
{MetricType: "task_completed_count", TargetValue: 2, TargetUnit: "count"},
|
|
},
|
|
})
|
|
if err != nil || !created {
|
|
t.Fatalf("UpsertAchievementDefinition failed: created=%v err=%v", created, err)
|
|
}
|
|
|
|
first, err := svc.ConsumeAchievementEvent(ctx, domain.Event{
|
|
EventID: "ach-event-1",
|
|
EventType: "TaskCompleted",
|
|
SourceService: "activity-service",
|
|
UserID: 10001,
|
|
MetricType: "task_completed_count",
|
|
Value: 1,
|
|
OccurredAtMS: fixedAchievementNow().UnixMilli(),
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("ConsumeAchievementEvent first failed: %v", err)
|
|
}
|
|
if first.MatchedAchievementCount != 1 || first.UnlockedAchievementCount != 0 {
|
|
t.Fatalf("first event mismatch: %+v", first)
|
|
}
|
|
|
|
second, err := svc.ConsumeAchievementEvent(ctx, domain.Event{
|
|
EventID: "ach-event-2",
|
|
EventType: "TaskCompleted",
|
|
SourceService: "activity-service",
|
|
UserID: 10001,
|
|
MetricType: "task_completed_count",
|
|
Value: 1,
|
|
OccurredAtMS: fixedAchievementNow().UnixMilli(),
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("ConsumeAchievementEvent second failed: %v", err)
|
|
}
|
|
if second.UnlockedAchievementCount != 1 || second.RewardJobCount != 1 {
|
|
t.Fatalf("second event mismatch: %+v", second)
|
|
}
|
|
|
|
duplicate, err := svc.ConsumeAchievementEvent(ctx, domain.Event{
|
|
EventID: "ach-event-2",
|
|
EventType: "TaskCompleted",
|
|
SourceService: "activity-service",
|
|
UserID: 10001,
|
|
MetricType: "task_completed_count",
|
|
Value: 1,
|
|
OccurredAtMS: fixedAchievementNow().UnixMilli(),
|
|
})
|
|
if err != nil || duplicate.Status != domain.EventStatusConsumed {
|
|
t.Fatalf("duplicate event should return existing consumed status: result=%+v err=%v", duplicate, err)
|
|
}
|
|
|
|
items, total, err := svc.ListAchievements(ctx, domain.ListQuery{UserID: 10001, CollectionType: domain.CollectionOrdinary})
|
|
if err != nil {
|
|
t.Fatalf("ListAchievements failed: %v", err)
|
|
}
|
|
if total != 1 || len(items) != 1 || items[0].AchievementID != definition.AchievementID || items[0].UserStatus != domain.UnlockStatusUnlocked || items[0].ProgressValue != 2 {
|
|
t.Fatalf("achievement read mismatch: total=%d items=%+v", total, items)
|
|
}
|
|
|
|
profile, err := svc.ListBadgeProfile(ctx, 10001)
|
|
if err != nil {
|
|
t.Fatalf("ListBadgeProfile failed: %v", err)
|
|
}
|
|
if len(profile.HonorBadges) != 1 || profile.HonorBadges[0].ResourceID != 7001 {
|
|
t.Fatalf("honor badge mismatch: %+v", profile)
|
|
}
|
|
if len(profile.ProfileTileBadges) != 1 || profile.ProfileTileBadges[0].ResourceID != 7001 {
|
|
t.Fatalf("profile tile badge mismatch: %+v", profile)
|
|
}
|
|
|
|
if _, err := svc.SetBadgeDisplay(ctx, domain.DisplayCommand{
|
|
UserID: 10001,
|
|
Slot: domain.BadgeSlotProfileTile,
|
|
CommandID: "cmd-badge-display-1",
|
|
Items: []domain.BadgeDisplayItem{
|
|
{ResourceID: 7001},
|
|
},
|
|
}); err != nil {
|
|
t.Fatalf("SetBadgeDisplay failed: %v", err)
|
|
}
|
|
|
|
claimed, processed, success, failure, hasMore, err := svc.ProcessAchievementRewardBatch(ctx, "run-1", "worker-1", 10, time.Second)
|
|
if err != nil {
|
|
t.Fatalf("ProcessAchievementRewardBatch failed: %v", err)
|
|
}
|
|
if claimed != 1 || processed != 1 || success != 1 || failure != 0 || hasMore || len(wallet.grants) != 1 {
|
|
t.Fatalf("reward batch mismatch: claimed=%d processed=%d success=%d failure=%d has_more=%v grants=%d", claimed, processed, success, failure, hasMore, len(wallet.grants))
|
|
}
|
|
}
|
|
|
|
func TestWalletBadgeGrantProjectsDisplaySlots(t *testing.T) {
|
|
svc, _ := newAchievementService(t)
|
|
ctx := appcode.WithContext(context.Background(), "lalu")
|
|
|
|
result, err := svc.ConsumeAchievementEvent(ctx, domain.Event{
|
|
EventID: "wallet-badge-event-1",
|
|
EventType: "ResourceGranted",
|
|
SourceService: "wallet-service",
|
|
UserID: 10001,
|
|
MetricType: "wallet_badge_grant",
|
|
Value: 1,
|
|
OccurredAtMS: fixedAchievementNow().UnixMilli(),
|
|
DimensionsJSON: `{"grant_id":"grant-badge-1","grant_source":"admin","items":[{"resource_id":8001,"resource_type":"badge","entitlement_id":"ent-badge-1","metadata_json":"{\"badge_form\":\"tile\"}"},{"resource_id":8002,"resource_type":"badge","entitlement_id":"ent-badge-2","metadata_json":"{\"badge_form\":\"strip\",\"default_slot\":\"profile_strip\"}"}]}`,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("ConsumeAchievementEvent wallet badge failed: %v", err)
|
|
}
|
|
if result.Status != domain.EventStatusConsumed {
|
|
t.Fatalf("wallet badge event should be consumed, got %+v", result)
|
|
}
|
|
|
|
profile, err := svc.ListBadgeProfile(ctx, 10001)
|
|
if err != nil {
|
|
t.Fatalf("ListBadgeProfile failed: %v", err)
|
|
}
|
|
if len(profile.HonorBadges) != 1 || profile.HonorBadges[0].ResourceID != 8001 || profile.HonorBadges[0].SourceType != domain.SourceSystemGrant {
|
|
t.Fatalf("honor badge projection mismatch: %+v", profile)
|
|
}
|
|
if len(profile.ProfileTileBadges) != 1 || profile.ProfileTileBadges[0].ResourceID != 8001 {
|
|
t.Fatalf("profile tile projection mismatch: %+v", profile)
|
|
}
|
|
if len(profile.StripBadges) != 1 || profile.StripBadges[0].ResourceID != 8002 || profile.StripBadges[0].BadgeForm != domain.BadgeFormStrip {
|
|
t.Fatalf("strip badge projection mismatch: %+v", profile)
|
|
}
|
|
|
|
duplicate, err := svc.ConsumeAchievementEvent(ctx, domain.Event{
|
|
EventID: "wallet-badge-event-1",
|
|
EventType: "ResourceGranted",
|
|
SourceService: "wallet-service",
|
|
UserID: 10001,
|
|
MetricType: "wallet_badge_grant",
|
|
Value: 1,
|
|
OccurredAtMS: fixedAchievementNow().UnixMilli(),
|
|
DimensionsJSON: `{"grant_id":"grant-badge-1","grant_source":"admin","items":[]}`,
|
|
})
|
|
if err != nil || duplicate.Status != domain.EventStatusConsumed {
|
|
t.Fatalf("duplicate wallet badge event should return existing status: result=%+v err=%v", duplicate, err)
|
|
}
|
|
}
|
|
|
|
func TestDirectBadgeAchievementWithoutConditions(t *testing.T) {
|
|
svc, _ := newAchievementService(t)
|
|
ctx := appcode.WithContext(context.Background(), "lalu")
|
|
|
|
if _, _, err := svc.UpsertAchievementDefinition(ctx, domain.DefinitionCommand{
|
|
CollectionType: domain.CollectionEvent,
|
|
AchievementType: domain.TypeActivityLimited,
|
|
Title: "活动徽章",
|
|
Description: "活动达成后展示",
|
|
Status: domain.StatusActive,
|
|
PrimaryBadgeResourceID: 8101,
|
|
OperatorAdminID: 90001,
|
|
}); err != nil {
|
|
t.Fatalf("UpsertAchievementDefinition without conditions failed: %v", err)
|
|
}
|
|
if _, err := svc.ConsumeAchievementEvent(ctx, domain.Event{
|
|
EventID: "wallet-badge-event-direct",
|
|
EventType: "ResourceGranted",
|
|
SourceService: "wallet-service",
|
|
UserID: 10002,
|
|
MetricType: "wallet_badge_grant",
|
|
Value: 1,
|
|
OccurredAtMS: fixedAchievementNow().UnixMilli(),
|
|
DimensionsJSON: `{"grant_id":"grant-badge-direct","grant_source":"admin","items":[{"resource_id":8101,"resource_type":"badge","entitlement_id":"ent-badge-direct","metadata_json":"{\"badge_form\":\"tile\"}"}]}`,
|
|
}); err != nil {
|
|
t.Fatalf("project badge resource failed: %v", err)
|
|
}
|
|
items, total, err := svc.ListAchievements(ctx, domain.ListQuery{UserID: 10002, CollectionType: domain.CollectionEvent})
|
|
if err != nil {
|
|
t.Fatalf("ListAchievements direct badge failed: %v", err)
|
|
}
|
|
if total != 1 || len(items) != 1 || items[0].UserStatus != domain.UnlockStatusUnlocked || items[0].ProgressValue != 1 || items[0].TargetValue != 1 {
|
|
t.Fatalf("direct badge achievement read mismatch: total=%d items=%+v", total, items)
|
|
}
|
|
|
|
deleted, err := svc.DeleteAchievementDefinition(ctx, items[0].AchievementID, 90001)
|
|
if err != nil || deleted.Status != domain.StatusArchived {
|
|
t.Fatalf("DeleteAchievementDefinition failed: item=%+v err=%v", deleted, err)
|
|
}
|
|
adminItems, adminTotal, err := svc.ListAchievementDefinitions(ctx, domain.ListQuery{CollectionType: domain.CollectionEvent})
|
|
if err != nil {
|
|
t.Fatalf("ListAchievementDefinitions after delete failed: %v", err)
|
|
}
|
|
if adminTotal != 0 || len(adminItems) != 0 {
|
|
t.Fatalf("archived achievement should be hidden by default: total=%d items=%+v", adminTotal, adminItems)
|
|
}
|
|
}
|
|
|
|
func TestAchievementListsReturnHighSortOrderFirst(t *testing.T) {
|
|
svc, _ := newAchievementService(t)
|
|
ctx := appcode.WithContext(context.Background(), "lalu")
|
|
definitions := []domain.DefinitionCommand{
|
|
{Title: "低优先级徽章", SortOrder: 10, PrimaryBadgeResourceID: 8201},
|
|
{Title: "高优先级徽章", SortOrder: 30, PrimaryBadgeResourceID: 8202},
|
|
{Title: "中优先级徽章", SortOrder: 20, PrimaryBadgeResourceID: 8203},
|
|
}
|
|
for _, definition := range definitions {
|
|
definition.CollectionType = domain.CollectionOrdinary
|
|
definition.AchievementType = domain.TypeOrdinary
|
|
definition.Status = domain.StatusActive
|
|
definition.OperatorAdminID = 90001
|
|
if _, _, err := svc.UpsertAchievementDefinition(ctx, definition); err != nil {
|
|
t.Fatalf("upsert sorted achievement failed: %v", err)
|
|
}
|
|
}
|
|
|
|
adminItems, adminTotal, err := svc.ListAchievementDefinitions(ctx, domain.ListQuery{CollectionType: domain.CollectionOrdinary})
|
|
if err != nil {
|
|
t.Fatalf("ListAchievementDefinitions sorted failed: %v", err)
|
|
}
|
|
if adminTotal != 3 || len(adminItems) != 3 {
|
|
t.Fatalf("admin sorted achievement count mismatch: total=%d items=%+v", adminTotal, adminItems)
|
|
}
|
|
if adminItems[0].SortOrder != 30 || adminItems[1].SortOrder != 20 || adminItems[2].SortOrder != 10 {
|
|
t.Fatalf("admin achievements should be sorted by sort_order desc: %+v", adminItems)
|
|
}
|
|
|
|
userItems, userTotal, err := svc.ListAchievements(ctx, domain.ListQuery{UserID: 10003, CollectionType: domain.CollectionOrdinary})
|
|
if err != nil {
|
|
t.Fatalf("ListAchievements sorted failed: %v", err)
|
|
}
|
|
if userTotal != 3 || len(userItems) != 3 {
|
|
t.Fatalf("user sorted achievement count mismatch: total=%d items=%+v", userTotal, userItems)
|
|
}
|
|
if userItems[0].SortOrder != 30 || userItems[1].SortOrder != 20 || userItems[2].SortOrder != 10 {
|
|
t.Fatalf("user achievements should be sorted by sort_order desc: %+v", userItems)
|
|
}
|
|
}
|
|
|
|
func newAchievementService(t *testing.T) (*achievementservice.Service, *fakeAchievementWallet) {
|
|
t.Helper()
|
|
repository := mysqltest.NewRepository(t)
|
|
wallet := &fakeAchievementWallet{}
|
|
svc := achievementservice.New(repository, wallet)
|
|
svc.SetClock(fixedAchievementNow)
|
|
return svc, wallet
|
|
}
|
|
|
|
func fixedAchievementNow() time.Time {
|
|
return time.Date(2026, 5, 14, 4, 0, 0, 0, time.UTC)
|
|
}
|
|
|
|
type fakeAchievementWallet struct {
|
|
grants []*walletv1.GrantResourceGroupRequest
|
|
}
|
|
|
|
func (f *fakeAchievementWallet) GrantResourceGroup(_ context.Context, req *walletv1.GrantResourceGroupRequest, _ ...grpc.CallOption) (*walletv1.ResourceGrantResponse, error) {
|
|
f.grants = append(f.grants, req)
|
|
return &walletv1.ResourceGrantResponse{
|
|
Grant: &walletv1.ResourceGrant{
|
|
GrantId: fmt.Sprintf("achievement-grant-%d", len(f.grants)),
|
|
Status: "succeeded",
|
|
},
|
|
}, nil
|
|
}
|