Ilia Denisov
363 lines
11 KiB
Go
363 lines
11 KiB
Go
package createinvite_test
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"io"
|
|
"log/slog"
|
|
"testing"
|
|
"time"
|
|
|
|
"galaxy/lobby/internal/adapters/gamestub"
|
|
"galaxy/lobby/internal/adapters/intentpubstub"
|
|
"galaxy/lobby/internal/adapters/invitestub"
|
|
"galaxy/lobby/internal/adapters/membershipstub"
|
|
"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/createinvite"
|
|
"galaxy/lobby/internal/service/shared"
|
|
"galaxy/notificationintent"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
const (
|
|
ownerUserID = "user-owner"
|
|
inviteeUserID = "user-invitee"
|
|
)
|
|
|
|
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 {
|
|
inviteID common.InviteID
|
|
}
|
|
|
|
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 f.inviteID, nil }
|
|
func (f fixedIDs) NewMembershipID() (common.MembershipID, error) { return "", errors.New("not used") }
|
|
|
|
type fixture struct {
|
|
now time.Time
|
|
games *gamestub.Store
|
|
invites *invitestub.Store
|
|
memberships *membershipstub.Store
|
|
intents *intentpubstub.Publisher
|
|
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)
|
|
games := gamestub.NewStore()
|
|
invites := invitestub.NewStore()
|
|
memberships := membershipstub.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))
|
|
|
|
return &fixture{
|
|
now: now,
|
|
games: games,
|
|
invites: invites,
|
|
memberships: memberships,
|
|
intents: intentpubstub.NewPublisher(),
|
|
ids: fixedIDs{inviteID: "invite-fixed"},
|
|
game: gameRecord,
|
|
}
|
|
}
|
|
|
|
func newService(t *testing.T, f *fixture) *createinvite.Service {
|
|
t.Helper()
|
|
svc, err := createinvite.NewService(createinvite.Dependencies{
|
|
Games: f.games,
|
|
Invites: f.invites,
|
|
Memberships: f.memberships,
|
|
Intents: f.intents,
|
|
IDs: f.ids,
|
|
Clock: fixedClock(f.now),
|
|
Logger: silentLogger(),
|
|
})
|
|
require.NoError(t, err)
|
|
return svc
|
|
}
|
|
|
|
func defaultInput(f *fixture) createinvite.Input {
|
|
return createinvite.Input{
|
|
Actor: shared.NewUserActor(ownerUserID),
|
|
GameID: f.game.GameID,
|
|
InviteeUserID: inviteeUserID,
|
|
}
|
|
}
|
|
|
|
func TestHandleHappyPath(t *testing.T) {
|
|
t.Parallel()
|
|
f := newFixture(t, 4, 1)
|
|
svc := newService(t, f)
|
|
|
|
got, err := svc.Handle(context.Background(), defaultInput(f))
|
|
require.NoError(t, err)
|
|
assert.Equal(t, common.InviteID("invite-fixed"), got.InviteID)
|
|
assert.Equal(t, ownerUserID, got.InviterUserID)
|
|
assert.Equal(t, inviteeUserID, got.InviteeUserID)
|
|
assert.Equal(t, invite.StatusCreated, got.Status)
|
|
assert.Equal(t, f.now, got.CreatedAt)
|
|
assert.Equal(t, f.game.EnrollmentEndsAt, got.ExpiresAt)
|
|
assert.Empty(t, got.RaceName)
|
|
|
|
intents := f.intents.Published()
|
|
require.Len(t, intents, 1)
|
|
assert.Equal(t, notificationintent.NotificationTypeLobbyInviteCreated, intents[0].NotificationType)
|
|
assert.Equal(t, []string{inviteeUserID}, intents[0].RecipientUserIDs)
|
|
}
|
|
|
|
func TestHandleAdminActorForbidden(t *testing.T) {
|
|
t.Parallel()
|
|
f := newFixture(t, 4, 1)
|
|
svc := newService(t, f)
|
|
|
|
input := defaultInput(f)
|
|
input.Actor = shared.NewAdminActor()
|
|
|
|
_, err := svc.Handle(context.Background(), input)
|
|
require.ErrorIs(t, err, shared.ErrForbidden)
|
|
}
|
|
|
|
func TestHandleNonOwnerForbidden(t *testing.T) {
|
|
t.Parallel()
|
|
f := newFixture(t, 4, 1)
|
|
svc := newService(t, f)
|
|
|
|
input := defaultInput(f)
|
|
input.Actor = shared.NewUserActor("user-impostor")
|
|
|
|
_, err := svc.Handle(context.Background(), input)
|
|
require.ErrorIs(t, err, shared.ErrForbidden)
|
|
}
|
|
|
|
func TestHandlePublicGameConflict(t *testing.T) {
|
|
t.Parallel()
|
|
f := newFixture(t, 4, 1)
|
|
|
|
publicGame, err := game.New(game.NewGameInput{
|
|
GameID: "game-public",
|
|
GameName: "Open",
|
|
GameType: game.GameTypePublic,
|
|
MinPlayers: 2,
|
|
MaxPlayers: 4,
|
|
StartGapHours: 2,
|
|
StartGapPlayers: 1,
|
|
EnrollmentEndsAt: f.now.Add(24 * time.Hour),
|
|
TurnSchedule: "0 */6 * * *",
|
|
TargetEngineVersion: "1.0.0",
|
|
Now: f.now,
|
|
})
|
|
require.NoError(t, err)
|
|
publicGame.Status = game.StatusEnrollmentOpen
|
|
require.NoError(t, f.games.Save(context.Background(), publicGame))
|
|
|
|
svc := newService(t, f)
|
|
input := defaultInput(f)
|
|
input.GameID = publicGame.GameID
|
|
|
|
_, err = svc.Handle(context.Background(), input)
|
|
require.ErrorIs(t, err, game.ErrConflict)
|
|
}
|
|
|
|
func TestHandleWrongStatusConflict(t *testing.T) {
|
|
t.Parallel()
|
|
f := newFixture(t, 4, 1)
|
|
rec, err := f.games.Get(context.Background(), f.game.GameID)
|
|
require.NoError(t, err)
|
|
rec.Status = game.StatusDraft
|
|
require.NoError(t, f.games.Save(context.Background(), rec))
|
|
|
|
svc := newService(t, f)
|
|
_, err = svc.Handle(context.Background(), defaultInput(f))
|
|
require.ErrorIs(t, err, game.ErrConflict)
|
|
}
|
|
|
|
func TestHandleRosterFullConflict(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))
|
|
}
|
|
|
|
svc := newService(t, f)
|
|
_, err := svc.Handle(context.Background(), defaultInput(f))
|
|
require.ErrorIs(t, err, game.ErrConflict)
|
|
}
|
|
|
|
func TestHandleDuplicateActiveInviteConflict(t *testing.T) {
|
|
t.Parallel()
|
|
f := newFixture(t, 4, 1)
|
|
existing, err := invite.New(invite.NewInviteInput{
|
|
InviteID: "invite-existing",
|
|
GameID: f.game.GameID,
|
|
InviterUserID: ownerUserID,
|
|
InviteeUserID: inviteeUserID,
|
|
Now: f.now,
|
|
ExpiresAt: f.game.EnrollmentEndsAt,
|
|
})
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.invites.Save(context.Background(), existing))
|
|
|
|
svc := newService(t, f)
|
|
_, err = svc.Handle(context.Background(), defaultInput(f))
|
|
require.ErrorIs(t, err, invite.ErrConflict)
|
|
}
|
|
|
|
func TestHandleDeclinedInviteAllowsReinvite(t *testing.T) {
|
|
t.Parallel()
|
|
f := newFixture(t, 4, 1)
|
|
declined, err := invite.New(invite.NewInviteInput{
|
|
InviteID: "invite-declined",
|
|
GameID: f.game.GameID,
|
|
InviterUserID: ownerUserID,
|
|
InviteeUserID: inviteeUserID,
|
|
Now: f.now.Add(-time.Hour),
|
|
ExpiresAt: f.game.EnrollmentEndsAt,
|
|
})
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.invites.Save(context.Background(), declined))
|
|
require.NoError(t, f.invites.UpdateStatus(context.Background(), ports.UpdateInviteStatusInput{
|
|
InviteID: declined.InviteID,
|
|
ExpectedFrom: invite.StatusCreated,
|
|
To: invite.StatusDeclined,
|
|
At: f.now,
|
|
}))
|
|
|
|
svc := newService(t, f)
|
|
got, err := svc.Handle(context.Background(), defaultInput(f))
|
|
require.NoError(t, err)
|
|
assert.Equal(t, common.InviteID("invite-fixed"), got.InviteID)
|
|
}
|
|
|
|
func TestHandleActiveMembershipBlocksInvite(t *testing.T) {
|
|
t.Parallel()
|
|
f := newFixture(t, 4, 1)
|
|
member, err := membership.New(membership.NewMembershipInput{
|
|
MembershipID: "membership-existing",
|
|
GameID: f.game.GameID,
|
|
UserID: inviteeUserID,
|
|
RaceName: "AlreadyMember",
|
|
CanonicalKey: "alreadymember",
|
|
Now: f.now,
|
|
})
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.memberships.Save(context.Background(), member))
|
|
|
|
svc := newService(t, f)
|
|
_, err = svc.Handle(context.Background(), defaultInput(f))
|
|
require.ErrorIs(t, err, membership.ErrConflict)
|
|
}
|
|
|
|
func TestHandleSelfInviteRejected(t *testing.T) {
|
|
t.Parallel()
|
|
f := newFixture(t, 4, 1)
|
|
svc := newService(t, f)
|
|
|
|
input := defaultInput(f)
|
|
input.InviteeUserID = ownerUserID
|
|
|
|
_, err := svc.Handle(context.Background(), input)
|
|
// invite.New refuses inviter == invitee with a validation error.
|
|
require.Error(t, err)
|
|
}
|
|
|
|
func TestHandleInviterNameUsesActiveMembershipRaceName(t *testing.T) {
|
|
t.Parallel()
|
|
f := newFixture(t, 4, 1)
|
|
ownerMember, err := membership.New(membership.NewMembershipInput{
|
|
MembershipID: "membership-owner",
|
|
GameID: f.game.GameID,
|
|
UserID: ownerUserID,
|
|
RaceName: "OwnerRace",
|
|
CanonicalKey: "ownerrace",
|
|
Now: f.now,
|
|
})
|
|
require.NoError(t, err)
|
|
require.NoError(t, f.memberships.Save(context.Background(), ownerMember))
|
|
|
|
svc := newService(t, f)
|
|
_, err = svc.Handle(context.Background(), defaultInput(f))
|
|
require.NoError(t, err)
|
|
|
|
intents := f.intents.Published()
|
|
require.Len(t, intents, 1)
|
|
assert.Contains(t, intents[0].PayloadJSON, `"inviter_name":"OwnerRace"`)
|
|
}
|
|
|
|
func TestHandleInviterNameFallsBackToUserID(t *testing.T) {
|
|
t.Parallel()
|
|
f := newFixture(t, 4, 1)
|
|
svc := newService(t, f)
|
|
|
|
_, err := svc.Handle(context.Background(), defaultInput(f))
|
|
require.NoError(t, err)
|
|
|
|
intents := f.intents.Published()
|
|
require.Len(t, intents, 1)
|
|
assert.Contains(t, intents[0].PayloadJSON, `"inviter_name":"`+ownerUserID+`"`)
|
|
}
|
|
|
|
func TestHandlePublishFailureDoesNotRollback(t *testing.T) {
|
|
t.Parallel()
|
|
f := newFixture(t, 4, 1)
|
|
f.intents.SetError(errors.New("publish failed"))
|
|
svc := newService(t, f)
|
|
|
|
got, err := svc.Handle(context.Background(), defaultInput(f))
|
|
require.NoError(t, err)
|
|
assert.Equal(t, common.InviteID("invite-fixed"), got.InviteID)
|
|
|
|
stored, err := f.invites.Get(context.Background(), got.InviteID)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, invite.StatusCreated, stored.Status)
|
|
}
|
|
|
|
func TestHandleGameNotFound(t *testing.T) {
|
|
t.Parallel()
|
|
f := newFixture(t, 4, 1)
|
|
svc := newService(t, f)
|
|
|
|
input := defaultInput(f)
|
|
input.GameID = "game-missing"
|
|
_, err := svc.Handle(context.Background(), input)
|
|
require.ErrorIs(t, err, game.ErrNotFound)
|
|
}
|
|
|