Ilia Denisov
303 lines
9.5 KiB
Go
303 lines
9.5 KiB
Go
package listgames_test
|
|
|
|
import (
|
|
"context"
|
|
"io"
|
|
"log/slog"
|
|
"testing"
|
|
"time"
|
|
|
|
"galaxy/lobby/internal/adapters/gameinmem"
|
|
"galaxy/lobby/internal/adapters/membershipinmem"
|
|
"galaxy/lobby/internal/domain/common"
|
|
"galaxy/lobby/internal/domain/game"
|
|
"galaxy/lobby/internal/domain/membership"
|
|
"galaxy/lobby/internal/service/listgames"
|
|
"galaxy/lobby/internal/service/shared"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func silentLogger() *slog.Logger {
|
|
return slog.New(slog.NewTextHandler(io.Discard, nil))
|
|
}
|
|
|
|
type fixture struct {
|
|
games *gameinmem.Store
|
|
memberships *membershipinmem.Store
|
|
svc *listgames.Service
|
|
}
|
|
|
|
func newFixture(t *testing.T) *fixture {
|
|
t.Helper()
|
|
games := gameinmem.NewStore()
|
|
memberships := membershipinmem.NewStore()
|
|
svc, err := listgames.NewService(listgames.Dependencies{
|
|
Games: games,
|
|
Memberships: memberships,
|
|
Logger: silentLogger(),
|
|
})
|
|
require.NoError(t, err)
|
|
return &fixture{games: games, memberships: memberships, svc: svc}
|
|
}
|
|
|
|
func seedGameAt(
|
|
t *testing.T,
|
|
store *gameinmem.Store,
|
|
id common.GameID,
|
|
gameType game.GameType,
|
|
ownerUserID string,
|
|
status game.Status,
|
|
createdAt time.Time,
|
|
) game.Game {
|
|
t.Helper()
|
|
record, err := game.New(game.NewGameInput{
|
|
GameID: id,
|
|
GameName: "Seed",
|
|
GameType: gameType,
|
|
OwnerUserID: ownerUserID,
|
|
MinPlayers: 2,
|
|
MaxPlayers: 4,
|
|
StartGapHours: 4,
|
|
StartGapPlayers: 1,
|
|
EnrollmentEndsAt: createdAt.Add(24 * time.Hour),
|
|
TurnSchedule: "0 */6 * * *",
|
|
TargetEngineVersion: "1.0.0",
|
|
Now: createdAt,
|
|
})
|
|
require.NoError(t, err)
|
|
if status != game.StatusDraft {
|
|
record.Status = status
|
|
record.UpdatedAt = createdAt.Add(time.Minute)
|
|
}
|
|
require.NoError(t, store.Save(context.Background(), record))
|
|
return record
|
|
}
|
|
|
|
func seedActiveMembership(
|
|
t *testing.T,
|
|
store *membershipinmem.Store,
|
|
gameID common.GameID,
|
|
userID string,
|
|
now time.Time,
|
|
) {
|
|
t.Helper()
|
|
record, err := membership.New(membership.NewMembershipInput{
|
|
MembershipID: common.MembershipID("membership-" + userID + "-" + gameID.String()),
|
|
GameID: gameID,
|
|
UserID: userID,
|
|
RaceName: "Race-" + userID,
|
|
CanonicalKey: "race-" + userID,
|
|
Now: now,
|
|
})
|
|
require.NoError(t, err)
|
|
require.NoError(t, store.Save(context.Background(), record))
|
|
}
|
|
|
|
func TestHandlePublicListExcludesDraftAndCancelled(t *testing.T) {
|
|
t.Parallel()
|
|
fix := newFixture(t)
|
|
now := time.Date(2025, 6, 1, 12, 0, 0, 0, time.UTC)
|
|
|
|
included := []game.Status{
|
|
game.StatusEnrollmentOpen, game.StatusReadyToStart,
|
|
game.StatusRunning, game.StatusFinished,
|
|
}
|
|
excluded := []game.Status{
|
|
game.StatusDraft, game.StatusCancelled, game.StatusPaused,
|
|
game.StatusStarting, game.StatusStartFailed,
|
|
}
|
|
for i, status := range included {
|
|
id := common.GameID("game-public-incl-" + string(status))
|
|
seedGameAt(t, fix.games, id, game.GameTypePublic, "", status, now.Add(time.Duration(i)*time.Minute))
|
|
}
|
|
for i, status := range excluded {
|
|
id := common.GameID("game-public-excl-" + string(status))
|
|
seedGameAt(t, fix.games, id, game.GameTypePublic, "", status, now.Add(time.Duration(i)*time.Minute))
|
|
}
|
|
|
|
out, err := fix.svc.Handle(context.Background(), listgames.Input{
|
|
Actor: shared.NewUserActor("user-stranger"),
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, out.Items, len(included))
|
|
for _, item := range out.Items {
|
|
require.Equal(t, game.GameTypePublic, item.GameType)
|
|
require.Contains(t, included, item.Status)
|
|
}
|
|
require.Empty(t, out.NextPageToken)
|
|
}
|
|
|
|
func TestHandlePublicListExcludesPrivateForStranger(t *testing.T) {
|
|
t.Parallel()
|
|
fix := newFixture(t)
|
|
now := time.Date(2025, 6, 1, 12, 0, 0, 0, time.UTC)
|
|
seedGameAt(t, fix.games, "game-private-1", game.GameTypePrivate, "user-owner",
|
|
game.StatusEnrollmentOpen, now)
|
|
|
|
out, err := fix.svc.Handle(context.Background(), listgames.Input{
|
|
Actor: shared.NewUserActor("user-stranger"),
|
|
})
|
|
require.NoError(t, err)
|
|
require.Empty(t, out.Items)
|
|
}
|
|
|
|
func TestHandleUserSeesOwnPrivateGames(t *testing.T) {
|
|
t.Parallel()
|
|
fix := newFixture(t)
|
|
now := time.Date(2025, 6, 1, 12, 0, 0, 0, time.UTC)
|
|
publicID := common.GameID("game-public-1")
|
|
seedGameAt(t, fix.games, publicID, game.GameTypePublic, "", game.StatusEnrollmentOpen, now)
|
|
privateID := common.GameID("game-private-mine")
|
|
seedGameAt(t, fix.games, privateID, game.GameTypePrivate, "user-owner", game.StatusRunning, now.Add(time.Minute))
|
|
seedActiveMembership(t, fix.memberships, privateID, "user-member", now)
|
|
|
|
out, err := fix.svc.Handle(context.Background(), listgames.Input{
|
|
Actor: shared.NewUserActor("user-member"),
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, out.Items, 2)
|
|
|
|
gotIDs := []common.GameID{out.Items[0].GameID, out.Items[1].GameID}
|
|
require.Contains(t, gotIDs, publicID)
|
|
require.Contains(t, gotIDs, privateID)
|
|
}
|
|
|
|
func TestHandleDedupesPrivateAlreadyVisible(t *testing.T) {
|
|
// A public game where the user also has a membership must appear
|
|
// only once in the response.
|
|
t.Parallel()
|
|
fix := newFixture(t)
|
|
now := time.Date(2025, 6, 1, 12, 0, 0, 0, time.UTC)
|
|
id := common.GameID("game-public-dedup")
|
|
seedGameAt(t, fix.games, id, game.GameTypePublic, "", game.StatusRunning, now)
|
|
seedActiveMembership(t, fix.memberships, id, "user-1", now)
|
|
|
|
out, err := fix.svc.Handle(context.Background(), listgames.Input{
|
|
Actor: shared.NewUserActor("user-1"),
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, out.Items, 1)
|
|
}
|
|
|
|
func TestHandlePrivateGameDraftHidden(t *testing.T) {
|
|
t.Parallel()
|
|
fix := newFixture(t)
|
|
now := time.Date(2025, 6, 1, 12, 0, 0, 0, time.UTC)
|
|
id := common.GameID("game-private-draft")
|
|
seedGameAt(t, fix.games, id, game.GameTypePrivate, "user-owner", game.StatusDraft, now)
|
|
seedActiveMembership(t, fix.memberships, id, "user-member", now)
|
|
|
|
out, err := fix.svc.Handle(context.Background(), listgames.Input{
|
|
Actor: shared.NewUserActor("user-member"),
|
|
})
|
|
require.NoError(t, err)
|
|
require.Empty(t, out.Items)
|
|
}
|
|
|
|
func TestHandleAdminSeesAllStatuses(t *testing.T) {
|
|
t.Parallel()
|
|
fix := newFixture(t)
|
|
now := time.Date(2025, 6, 1, 12, 0, 0, 0, time.UTC)
|
|
statuses := []game.Status{
|
|
game.StatusDraft, game.StatusEnrollmentOpen, game.StatusReadyToStart,
|
|
game.StatusStarting, game.StatusStartFailed, game.StatusRunning,
|
|
game.StatusPaused, game.StatusFinished, game.StatusCancelled,
|
|
}
|
|
for i, status := range statuses {
|
|
id := common.GameID("game-admin-" + string(status))
|
|
seedGameAt(t, fix.games, id, game.GameTypePublic, "", status, now.Add(time.Duration(i)*time.Minute))
|
|
}
|
|
|
|
out, err := fix.svc.Handle(context.Background(), listgames.Input{
|
|
Actor: shared.NewAdminActor(),
|
|
Page: shared.Page{Size: 50},
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, out.Items, len(statuses))
|
|
}
|
|
|
|
func TestHandleSortGroupAndCreatedAt(t *testing.T) {
|
|
t.Parallel()
|
|
fix := newFixture(t)
|
|
base := time.Date(2025, 6, 1, 12, 0, 0, 0, time.UTC)
|
|
|
|
seedGameAt(t, fix.games, "game-running-old", game.GameTypePublic, "", game.StatusRunning, base)
|
|
seedGameAt(t, fix.games, "game-running-new", game.GameTypePublic, "", game.StatusRunning, base.Add(2*time.Hour))
|
|
seedGameAt(t, fix.games, "game-finished", game.GameTypePublic, "", game.StatusFinished, base.Add(time.Hour))
|
|
seedGameAt(t, fix.games, "game-enroll", game.GameTypePublic, "", game.StatusEnrollmentOpen, base.Add(30*time.Minute))
|
|
seedGameAt(t, fix.games, "game-ready", game.GameTypePublic, "", game.StatusReadyToStart, base.Add(45*time.Minute))
|
|
|
|
out, err := fix.svc.Handle(context.Background(), listgames.Input{
|
|
Actor: shared.NewUserActor("user-1"),
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, out.Items, 5)
|
|
|
|
// Group 0: ready-to-start (created later) before enroll (created earlier).
|
|
require.Equal(t, common.GameID("game-ready"), out.Items[0].GameID)
|
|
require.Equal(t, common.GameID("game-enroll"), out.Items[1].GameID)
|
|
// Group 1: running, descending CreatedAt.
|
|
require.Equal(t, common.GameID("game-running-new"), out.Items[2].GameID)
|
|
require.Equal(t, common.GameID("game-running-old"), out.Items[3].GameID)
|
|
// Group 2: finished.
|
|
require.Equal(t, common.GameID("game-finished"), out.Items[4].GameID)
|
|
}
|
|
|
|
func TestHandlePagination(t *testing.T) {
|
|
t.Parallel()
|
|
fix := newFixture(t)
|
|
base := time.Date(2025, 6, 1, 12, 0, 0, 0, time.UTC)
|
|
for i := range 5 {
|
|
id := common.GameID("game-page-" + string(rune('a'+i)))
|
|
seedGameAt(t, fix.games, id, game.GameTypePublic, "", game.StatusRunning,
|
|
base.Add(time.Duration(i)*time.Minute))
|
|
}
|
|
|
|
first, err := fix.svc.Handle(context.Background(), listgames.Input{
|
|
Actor: shared.NewUserActor("user-1"),
|
|
Page: shared.Page{Size: 2},
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, first.Items, 2)
|
|
require.NotEmpty(t, first.NextPageToken)
|
|
|
|
page2, err := shared.ParsePage("2", first.NextPageToken)
|
|
require.NoError(t, err)
|
|
second, err := fix.svc.Handle(context.Background(), listgames.Input{
|
|
Actor: shared.NewUserActor("user-1"),
|
|
Page: page2,
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, second.Items, 2)
|
|
require.NotEmpty(t, second.NextPageToken)
|
|
|
|
page3, err := shared.ParsePage("2", second.NextPageToken)
|
|
require.NoError(t, err)
|
|
third, err := fix.svc.Handle(context.Background(), listgames.Input{
|
|
Actor: shared.NewUserActor("user-1"),
|
|
Page: page3,
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, third.Items, 1)
|
|
require.Empty(t, third.NextPageToken)
|
|
}
|
|
|
|
func TestNewServiceRejectsMissingDeps(t *testing.T) {
|
|
t.Parallel()
|
|
cases := []struct {
|
|
name string
|
|
deps listgames.Dependencies
|
|
}{
|
|
{"nil games", listgames.Dependencies{Memberships: membershipinmem.NewStore()}},
|
|
{"nil memberships", listgames.Dependencies{Games: gameinmem.NewStore()}},
|
|
}
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
_, err := listgames.NewService(tc.deps)
|
|
require.Error(t, err)
|
|
})
|
|
}
|
|
}
|