Ilia Denisov
556 lines
16 KiB
Go
556 lines
16 KiB
Go
package redeeminvite_test
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"io"
|
|
"log/slog"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"galaxy/lobby/internal/adapters/gameinmem"
|
|
"galaxy/lobby/internal/adapters/gapactivationinmem"
|
|
"galaxy/lobby/internal/adapters/inviteinmem"
|
|
"galaxy/lobby/internal/adapters/membershipinmem"
|
|
"galaxy/lobby/internal/adapters/mocks"
|
|
"galaxy/lobby/internal/adapters/racenameinmem"
|
|
"galaxy/lobby/internal/domain/common"
|
|
"galaxy/lobby/internal/domain/game"
|
|
"galaxy/lobby/internal/domain/invite"
|
|
"galaxy/lobby/internal/domain/membership"
|
|
"galaxy/lobby/internal/ports"
|
|
"galaxy/lobby/internal/service/redeeminvite"
|
|
"galaxy/lobby/internal/service/shared"
|
|
"galaxy/notificationintent"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"go.uber.org/mock/gomock"
|
|
)
|
|
|
|
type intentRec struct {
|
|
mu sync.Mutex
|
|
published []notificationintent.Intent
|
|
err error
|
|
}
|
|
|
|
func (r *intentRec) record(_ context.Context, intent notificationintent.Intent) (string, error) {
|
|
r.mu.Lock()
|
|
defer r.mu.Unlock()
|
|
if r.err != nil {
|
|
return "", r.err
|
|
}
|
|
r.published = append(r.published, intent)
|
|
return "1", nil
|
|
}
|
|
|
|
func (r *intentRec) snapshot() []notificationintent.Intent {
|
|
r.mu.Lock()
|
|
defer r.mu.Unlock()
|
|
return append([]notificationintent.Intent(nil), r.published...)
|
|
}
|
|
|
|
func (r *intentRec) setErr(err error) {
|
|
r.mu.Lock()
|
|
defer r.mu.Unlock()
|
|
r.err = err
|
|
}
|
|
|
|
type userRec struct {
|
|
mu sync.Mutex
|
|
elig map[string]ports.Eligibility
|
|
failures map[string]error
|
|
}
|
|
|
|
func (r *userRec) record(_ context.Context, userID string) (ports.Eligibility, error) {
|
|
r.mu.Lock()
|
|
defer r.mu.Unlock()
|
|
if err, ok := r.failures[userID]; ok {
|
|
return ports.Eligibility{}, err
|
|
}
|
|
if e, ok := r.elig[userID]; ok {
|
|
return e, nil
|
|
}
|
|
return ports.Eligibility{Exists: false}, nil
|
|
}
|
|
|
|
func (r *userRec) setEligibility(userID string, e ports.Eligibility) {
|
|
r.mu.Lock()
|
|
defer r.mu.Unlock()
|
|
if r.elig == nil {
|
|
r.elig = make(map[string]ports.Eligibility)
|
|
}
|
|
r.elig[userID] = e
|
|
}
|
|
|
|
func (r *userRec) setFailure(userID string, err error) {
|
|
r.mu.Lock()
|
|
defer r.mu.Unlock()
|
|
if r.failures == nil {
|
|
r.failures = make(map[string]error)
|
|
}
|
|
r.failures[userID] = err
|
|
}
|
|
|
|
func newIntentMock(t *testing.T, rec *intentRec) *mocks.MockIntentPublisher {
|
|
t.Helper()
|
|
m := mocks.NewMockIntentPublisher(gomock.NewController(t))
|
|
m.EXPECT().Publish(gomock.Any(), gomock.Any()).DoAndReturn(rec.record).AnyTimes()
|
|
return m
|
|
}
|
|
|
|
func newUserMock(t *testing.T, rec *userRec) *mocks.MockUserService {
|
|
t.Helper()
|
|
m := mocks.NewMockUserService(gomock.NewController(t))
|
|
m.EXPECT().GetEligibility(gomock.Any(), gomock.Any()).DoAndReturn(rec.record).AnyTimes()
|
|
return m
|
|
}
|
|
|
|
const (
|
|
ownerUserID = "user-owner"
|
|
inviteeUserID = "user-invitee"
|
|
defaultRace = "VoidRunner"
|
|
)
|
|
|
|
func silentLogger() *slog.Logger { return slog.New(slog.NewTextHandler(io.Discard, nil)) }
|
|
|
|
func fixedClock(at time.Time) func() time.Time { return func() time.Time { return at } }
|
|
|
|
type fixedIDs struct {
|
|
membershipID common.MembershipID
|
|
}
|
|
|
|
func (f fixedIDs) NewGameID() (common.GameID, error) { return "", errors.New("not used") }
|
|
func (f fixedIDs) NewApplicationID() (common.ApplicationID, error) { return "", errors.New("not used") }
|
|
func (f fixedIDs) NewInviteID() (common.InviteID, error) { return "", errors.New("not used") }
|
|
func (f fixedIDs) NewMembershipID() (common.MembershipID, error) { return f.membershipID, nil }
|
|
|
|
type fixture struct {
|
|
now time.Time
|
|
games *gameinmem.Store
|
|
invites *inviteinmem.Store
|
|
memberships *membershipinmem.Store
|
|
directory *racenameinmem.Directory
|
|
users *userRec
|
|
usersMock *mocks.MockUserService
|
|
gapStore *gapactivationinmem.Store
|
|
intents *intentRec
|
|
intentsMock *mocks.MockIntentPublisher
|
|
ids fixedIDs
|
|
game game.Game
|
|
}
|
|
|
|
func newFixture(t *testing.T, maxPlayers, gapPlayers int) *fixture {
|
|
t.Helper()
|
|
now := time.Date(2026, 4, 25, 10, 0, 0, 0, time.UTC)
|
|
dir, err := racenameinmem.NewDirectory(racenameinmem.WithClock(fixedClock(now)))
|
|
require.NoError(t, err)
|
|
games := gameinmem.NewStore()
|
|
invites := inviteinmem.NewStore()
|
|
memberships := membershipinmem.NewStore()
|
|
|
|
gameRecord, err := game.New(game.NewGameInput{
|
|
GameID: "game-private",
|
|
GameName: "Friends Only",
|
|
GameType: game.GameTypePrivate,
|
|
OwnerUserID: ownerUserID,
|
|
MinPlayers: 2,
|
|
MaxPlayers: maxPlayers,
|
|
StartGapHours: 2,
|
|
StartGapPlayers: gapPlayers,
|
|
EnrollmentEndsAt: now.Add(24 * time.Hour),
|
|
TurnSchedule: "0 */6 * * *",
|
|
TargetEngineVersion: "1.0.0",
|
|
Now: now,
|
|
})
|
|
require.NoError(t, err)
|
|
gameRecord.Status = game.StatusEnrollmentOpen
|
|
require.NoError(t, games.Save(context.Background(), gameRecord))
|
|
|
|
users := &userRec{}
|
|
activeEligibility := ports.Eligibility{
|
|
Exists: true,
|
|
CanLogin: true,
|
|
CanCreatePrivateGame: true,
|
|
CanManagePrivateGame: true,
|
|
CanJoinGame: true,
|
|
CanUpdateProfile: true,
|
|
}
|
|
users.setEligibility(ownerUserID, activeEligibility)
|
|
users.setEligibility(inviteeUserID, activeEligibility)
|
|
|
|
intents := &intentRec{}
|
|
return &fixture{
|
|
now: now,
|
|
games: games,
|
|
invites: invites,
|
|
memberships: memberships,
|
|
directory: dir,
|
|
users: users,
|
|
usersMock: newUserMock(t, users),
|
|
gapStore: gapactivationinmem.NewStore(),
|
|
intents: intents,
|
|
intentsMock: newIntentMock(t, intents),
|
|
ids: fixedIDs{membershipID: "membership-fixed"},
|
|
game: gameRecord,
|
|
}
|
|
}
|
|
|
|
func newService(t *testing.T, f *fixture) *redeeminvite.Service {
|
|
t.Helper()
|
|
svc, err := redeeminvite.NewService(redeeminvite.Dependencies{
|
|
Games: f.games,
|
|
Invites: f.invites,
|
|
Memberships: f.memberships,
|
|
Directory: f.directory,
|
|
Users: f.usersMock,
|
|
GapStore: f.gapStore,
|
|
Intents: f.intentsMock,
|
|
IDs: f.ids,
|
|
Clock: fixedClock(f.now),
|
|
Logger: silentLogger(),
|
|
})
|
|
require.NoError(t, err)
|
|
return svc
|
|
}
|
|
|
|
func seedCreatedInvite(t *testing.T, f *fixture, inviteID common.InviteID, invitee string) invite.Invite {
|
|
t.Helper()
|
|
inv, err := invite.New(invite.NewInviteInput{
|
|
InviteID: inviteID,
|
|
GameID: f.game.GameID,
|
|
InviterUserID: ownerUserID,
|
|
InviteeUserID: invitee,
|
|
Now: f.now,
|
|
ExpiresAt: f.game.EnrollmentEndsAt,
|
|
})
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.invites.Save(context.Background(), inv))
|
|
return inv
|
|
}
|
|
|
|
func defaultInput(f *fixture, inv invite.Invite) redeeminvite.Input {
|
|
return redeeminvite.Input{
|
|
Actor: shared.NewUserActor(inviteeUserID),
|
|
GameID: f.game.GameID,
|
|
InviteID: inv.InviteID,
|
|
RaceName: defaultRace,
|
|
}
|
|
}
|
|
|
|
func TestRedeemHappyPath(t *testing.T) {
|
|
t.Parallel()
|
|
f := newFixture(t, 4, 1)
|
|
inv := seedCreatedInvite(t, f, "invite-1", inviteeUserID)
|
|
svc := newService(t, f)
|
|
|
|
got, err := svc.Handle(context.Background(), defaultInput(f, inv))
|
|
require.NoError(t, err)
|
|
assert.Equal(t, common.MembershipID("membership-fixed"), got.MembershipID)
|
|
assert.Equal(t, defaultRace, got.RaceName)
|
|
assert.Equal(t, "voidrunner", got.CanonicalKey)
|
|
assert.Equal(t, membership.StatusActive, got.Status)
|
|
assert.Equal(t, f.now, got.JoinedAt)
|
|
assert.Equal(t, inviteeUserID, got.UserID)
|
|
|
|
updated, err := f.invites.Get(context.Background(), inv.InviteID)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, invite.StatusRedeemed, updated.Status)
|
|
assert.Equal(t, defaultRace, updated.RaceName)
|
|
require.NotNil(t, updated.DecidedAt)
|
|
|
|
avail, err := f.directory.Check(context.Background(), defaultRace, "user-other")
|
|
require.NoError(t, err)
|
|
assert.True(t, avail.Taken)
|
|
assert.Equal(t, inviteeUserID, avail.HolderUserID)
|
|
|
|
intents := f.intents.snapshot()
|
|
require.Len(t, intents, 1)
|
|
assert.Equal(t, notificationintent.NotificationTypeLobbyInviteRedeemed, intents[0].NotificationType)
|
|
assert.Equal(t, []string{ownerUserID}, intents[0].RecipientUserIDs)
|
|
assert.Contains(t, intents[0].PayloadJSON, `"invitee_name":"`+defaultRace+`"`)
|
|
|
|
assert.False(t, f.gapStore.WasActivated(f.game.GameID))
|
|
}
|
|
|
|
func TestRedeemRejectsInviterPermanentBlock(t *testing.T) {
|
|
t.Parallel()
|
|
f := newFixture(t, 4, 1)
|
|
inv := seedCreatedInvite(t, f, "invite-1", inviteeUserID)
|
|
f.users.setEligibility(ownerUserID, ports.Eligibility{
|
|
Exists: true,
|
|
PermanentBlocked: true,
|
|
})
|
|
svc := newService(t, f)
|
|
|
|
_, err := svc.Handle(context.Background(), defaultInput(f, inv))
|
|
require.ErrorIs(t, err, shared.ErrSubjectNotFound)
|
|
|
|
updated, err := f.invites.Get(context.Background(), inv.InviteID)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, invite.StatusCreated, updated.Status, "invite must remain unchanged on aborted redeem")
|
|
}
|
|
|
|
func TestRedeemRejectsInviteePermanentBlock(t *testing.T) {
|
|
t.Parallel()
|
|
f := newFixture(t, 4, 1)
|
|
inv := seedCreatedInvite(t, f, "invite-1", inviteeUserID)
|
|
f.users.setEligibility(inviteeUserID, ports.Eligibility{
|
|
Exists: true,
|
|
PermanentBlocked: true,
|
|
})
|
|
svc := newService(t, f)
|
|
|
|
_, err := svc.Handle(context.Background(), defaultInput(f, inv))
|
|
require.ErrorIs(t, err, shared.ErrSubjectNotFound)
|
|
}
|
|
|
|
func TestRedeemRejectsDeletedInviter(t *testing.T) {
|
|
t.Parallel()
|
|
f := newFixture(t, 4, 1)
|
|
inv := seedCreatedInvite(t, f, "invite-1", inviteeUserID)
|
|
f.users.setEligibility(ownerUserID, ports.Eligibility{Exists: false})
|
|
svc := newService(t, f)
|
|
|
|
_, err := svc.Handle(context.Background(), defaultInput(f, inv))
|
|
require.ErrorIs(t, err, shared.ErrSubjectNotFound)
|
|
}
|
|
|
|
func TestRedeemSurfacesUserServiceTransportFailure(t *testing.T) {
|
|
t.Parallel()
|
|
f := newFixture(t, 4, 1)
|
|
inv := seedCreatedInvite(t, f, "invite-1", inviteeUserID)
|
|
f.users.setFailure(ownerUserID, ports.ErrUserServiceUnavailable)
|
|
svc := newService(t, f)
|
|
|
|
_, err := svc.Handle(context.Background(), defaultInput(f, inv))
|
|
require.ErrorIs(t, err, shared.ErrServiceUnavailable)
|
|
}
|
|
|
|
func TestRedeemActivatesGapAtMaxPlayers(t *testing.T) {
|
|
t.Parallel()
|
|
// max=2, gap=1; pre-seed 1 active member. Redeem pushes count to 2 (== max).
|
|
f := newFixture(t, 2, 1)
|
|
preexisting, err := membership.New(membership.NewMembershipInput{
|
|
MembershipID: "membership-pre",
|
|
GameID: f.game.GameID,
|
|
UserID: "user-pre",
|
|
RaceName: "PriorMember",
|
|
CanonicalKey: "priormember",
|
|
Now: f.now,
|
|
})
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.memberships.Save(context.Background(), preexisting))
|
|
|
|
inv := seedCreatedInvite(t, f, "invite-1", inviteeUserID)
|
|
svc := newService(t, f)
|
|
|
|
_, err = svc.Handle(context.Background(), defaultInput(f, inv))
|
|
require.NoError(t, err)
|
|
assert.True(t, f.gapStore.WasActivated(f.game.GameID))
|
|
assert.Equal(t, f.now, f.gapStore.ActivatedAt(f.game.GameID))
|
|
}
|
|
|
|
func TestRedeemDoesNotActivateGapBelowMax(t *testing.T) {
|
|
t.Parallel()
|
|
f := newFixture(t, 4, 1)
|
|
inv := seedCreatedInvite(t, f, "invite-1", inviteeUserID)
|
|
svc := newService(t, f)
|
|
|
|
_, err := svc.Handle(context.Background(), defaultInput(f, inv))
|
|
require.NoError(t, err)
|
|
assert.False(t, f.gapStore.WasActivated(f.game.GameID))
|
|
}
|
|
|
|
func TestRedeemAdminActorForbidden(t *testing.T) {
|
|
t.Parallel()
|
|
f := newFixture(t, 4, 1)
|
|
inv := seedCreatedInvite(t, f, "invite-1", inviteeUserID)
|
|
svc := newService(t, f)
|
|
|
|
in := defaultInput(f, inv)
|
|
in.Actor = shared.NewAdminActor()
|
|
|
|
_, err := svc.Handle(context.Background(), in)
|
|
require.ErrorIs(t, err, shared.ErrForbidden)
|
|
}
|
|
|
|
func TestRedeemNonInviteeForbidden(t *testing.T) {
|
|
t.Parallel()
|
|
f := newFixture(t, 4, 1)
|
|
inv := seedCreatedInvite(t, f, "invite-1", inviteeUserID)
|
|
svc := newService(t, f)
|
|
|
|
in := defaultInput(f, inv)
|
|
in.Actor = shared.NewUserActor("user-impostor")
|
|
|
|
_, err := svc.Handle(context.Background(), in)
|
|
require.ErrorIs(t, err, shared.ErrForbidden)
|
|
}
|
|
|
|
func TestRedeemInviteNotFound(t *testing.T) {
|
|
t.Parallel()
|
|
f := newFixture(t, 4, 1)
|
|
svc := newService(t, f)
|
|
|
|
_, err := svc.Handle(context.Background(), redeeminvite.Input{
|
|
Actor: shared.NewUserActor(inviteeUserID),
|
|
GameID: f.game.GameID,
|
|
InviteID: "invite-missing",
|
|
RaceName: defaultRace,
|
|
})
|
|
require.ErrorIs(t, err, invite.ErrNotFound)
|
|
}
|
|
|
|
func TestRedeemCrossGameInviteNotFound(t *testing.T) {
|
|
t.Parallel()
|
|
f := newFixture(t, 4, 1)
|
|
inv := seedCreatedInvite(t, f, "invite-1", inviteeUserID)
|
|
svc := newService(t, f)
|
|
|
|
in := defaultInput(f, inv)
|
|
in.GameID = "game-other"
|
|
|
|
_, err := svc.Handle(context.Background(), in)
|
|
require.ErrorIs(t, err, invite.ErrNotFound)
|
|
}
|
|
|
|
func TestRedeemAlreadyRedeemedConflict(t *testing.T) {
|
|
t.Parallel()
|
|
f := newFixture(t, 4, 1)
|
|
inv := seedCreatedInvite(t, f, "invite-1", inviteeUserID)
|
|
require.NoError(t, f.invites.UpdateStatus(context.Background(), ports.UpdateInviteStatusInput{
|
|
InviteID: inv.InviteID,
|
|
ExpectedFrom: invite.StatusCreated,
|
|
To: invite.StatusDeclined,
|
|
At: f.now,
|
|
}))
|
|
|
|
svc := newService(t, f)
|
|
_, err := svc.Handle(context.Background(), defaultInput(f, inv))
|
|
require.ErrorIs(t, err, invite.ErrConflict)
|
|
}
|
|
|
|
func TestRedeemGameNotEnrollmentOpenConflict(t *testing.T) {
|
|
t.Parallel()
|
|
f := newFixture(t, 4, 1)
|
|
inv := seedCreatedInvite(t, f, "invite-1", inviteeUserID)
|
|
|
|
rec, err := f.games.Get(context.Background(), f.game.GameID)
|
|
require.NoError(t, err)
|
|
rec.Status = game.StatusReadyToStart
|
|
require.NoError(t, f.games.Save(context.Background(), rec))
|
|
|
|
svc := newService(t, f)
|
|
_, err = svc.Handle(context.Background(), defaultInput(f, inv))
|
|
require.ErrorIs(t, err, game.ErrConflict)
|
|
}
|
|
|
|
func TestRedeemRosterFullConflict(t *testing.T) {
|
|
t.Parallel()
|
|
// Capacity = max(2) + gap(1) = 3; seed 3 active members.
|
|
f := newFixture(t, 2, 1)
|
|
for i := range 3 {
|
|
member, err := membership.New(membership.NewMembershipInput{
|
|
MembershipID: common.MembershipID("membership-seed-" + string(rune('a'+i))),
|
|
GameID: f.game.GameID,
|
|
UserID: "seed-user-" + string(rune('a'+i)),
|
|
RaceName: "Seed " + string(rune('A'+i)),
|
|
CanonicalKey: "seed" + string(rune('a'+i)),
|
|
Now: f.now,
|
|
})
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.memberships.Save(context.Background(), member))
|
|
}
|
|
inv := seedCreatedInvite(t, f, "invite-1", inviteeUserID)
|
|
svc := newService(t, f)
|
|
|
|
_, err := svc.Handle(context.Background(), defaultInput(f, inv))
|
|
require.ErrorIs(t, err, game.ErrConflict)
|
|
}
|
|
|
|
func TestRedeemNameTakenByAnotherUser(t *testing.T) {
|
|
t.Parallel()
|
|
f := newFixture(t, 4, 1)
|
|
require.NoError(t, f.directory.Reserve(context.Background(), "game-other", "user-other", defaultRace))
|
|
inv := seedCreatedInvite(t, f, "invite-1", inviteeUserID)
|
|
svc := newService(t, f)
|
|
|
|
_, err := svc.Handle(context.Background(), defaultInput(f, inv))
|
|
require.ErrorIs(t, err, ports.ErrNameTaken)
|
|
}
|
|
|
|
func TestRedeemInvalidRaceName(t *testing.T) {
|
|
t.Parallel()
|
|
f := newFixture(t, 4, 1)
|
|
inv := seedCreatedInvite(t, f, "invite-1", inviteeUserID)
|
|
svc := newService(t, f)
|
|
|
|
in := defaultInput(f, inv)
|
|
in.RaceName = " "
|
|
|
|
_, err := svc.Handle(context.Background(), in)
|
|
require.ErrorIs(t, err, ports.ErrInvalidName)
|
|
}
|
|
|
|
// redeemCASStub wraps inviteinmem.Store but injects ErrConflict on the next
|
|
// UpdateStatus call so we can observe the rollback path.
|
|
type redeemCASStub struct {
|
|
*inviteinmem.Store
|
|
failNext bool
|
|
}
|
|
|
|
func (s *redeemCASStub) UpdateStatus(ctx context.Context, input ports.UpdateInviteStatusInput) error {
|
|
if s.failNext {
|
|
s.failNext = false
|
|
return invite.ErrConflict
|
|
}
|
|
return s.Store.UpdateStatus(ctx, input)
|
|
}
|
|
|
|
func TestRedeemCASConflictReleasesReservation(t *testing.T) {
|
|
t.Parallel()
|
|
f := newFixture(t, 4, 1)
|
|
inv := seedCreatedInvite(t, f, "invite-1", inviteeUserID)
|
|
|
|
cas := &redeemCASStub{Store: f.invites, failNext: true}
|
|
svc, err := redeeminvite.NewService(redeeminvite.Dependencies{
|
|
Games: f.games,
|
|
Invites: cas,
|
|
Memberships: f.memberships,
|
|
Directory: f.directory,
|
|
Users: f.usersMock,
|
|
GapStore: f.gapStore,
|
|
Intents: f.intentsMock,
|
|
IDs: f.ids,
|
|
Clock: fixedClock(f.now),
|
|
Logger: silentLogger(),
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
_, err = svc.Handle(context.Background(), defaultInput(f, inv))
|
|
require.ErrorIs(t, err, invite.ErrConflict)
|
|
|
|
avail, err := f.directory.Check(context.Background(), defaultRace, "user-other")
|
|
require.NoError(t, err)
|
|
assert.False(t, avail.Taken, "reservation must be released after CAS failure")
|
|
assert.Empty(t, avail.HolderUserID)
|
|
}
|
|
|
|
func TestRedeemPublishFailureDoesNotRollback(t *testing.T) {
|
|
t.Parallel()
|
|
f := newFixture(t, 4, 1)
|
|
inv := seedCreatedInvite(t, f, "invite-1", inviteeUserID)
|
|
f.intents.setErr(errors.New("publish failed"))
|
|
|
|
svc := newService(t, f)
|
|
got, err := svc.Handle(context.Background(), defaultInput(f, inv))
|
|
require.NoError(t, err)
|
|
assert.Equal(t, common.MembershipID("membership-fixed"), got.MembershipID)
|
|
|
|
updated, err := f.invites.Get(context.Background(), inv.InviteID)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, invite.StatusRedeemed, updated.Status)
|
|
}
|