feat: game lobby service

2026-04-25 23:20:55 +02:00
parent 32dc29359a
commit 48b0056b49
336 changed files with 57074 additions and 1418 deletions
@@ -0,0 +1,193 @@
+// Package manualreadytostart implements the `lobby.game.ready_to_start`
+// message type. It transitions a game record from `enrollment_open` to
+// `ready_to_start` after enforcing admin-or-owner authorization and the
+// `approved_count >= min_players` precondition. Side effects (expiring
+// every still-created invite and publishing `lobby.invite.expired`) are
+// delegated to shared.CloseEnrollment so the auto-close path used by the
+// enrollment automation worker stays in sync.
+package manualreadytostart
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log/slog"
+	"time"
+
+	"galaxy/lobby/internal/domain/common"
+	"galaxy/lobby/internal/domain/game"
+	"galaxy/lobby/internal/logging"
+	"galaxy/lobby/internal/ports"
+	"galaxy/lobby/internal/service/shared"
+	"galaxy/lobby/internal/telemetry"
+)
+
+// Service executes the manual ready-to-start use case.
+type Service struct {
+	games       ports.GameStore
+	memberships ports.MembershipStore
+	invites     ports.InviteStore
+	intents     ports.IntentPublisher
+	clock       func() time.Time
+	logger      *slog.Logger
+	telemetry   *telemetry.Runtime
+}
+
+// Dependencies groups the collaborators used by Service.
+type Dependencies struct {
+	// Games mediates the CAS status transition and the result read.
+	Games ports.GameStore
+
+	// Memberships is scanned for active records to evaluate the
+	// approved_count >= min_players precondition.
+	Memberships ports.MembershipStore
+
+	// Invites is forwarded to shared.CloseEnrollment for the cascading
+	// expiry of created invites on close.
+	Invites ports.InviteStore
+
+	// Intents publishes lobby.invite.expired notifications produced by
+	// the cascading expiry.
+	Intents ports.IntentPublisher
+
+	// Clock supplies the wall-clock used for UpdatedAt and downstream
+	// notification timestamps. Defaults to time.Now when nil.
+	Clock func() time.Time
+
+	// Logger records structured service-level events. Defaults to
+	// slog.Default when nil.
+	Logger *slog.Logger
+
+	// Telemetry forwards into shared.CloseEnrollment so the
+	// `lobby.game.transitions` and `lobby.invite.outcomes` counters
+	// are emitted on each manual close. Optional; nil disables metric
+	// emission.
+	Telemetry *telemetry.Runtime
+}
+
+// NewService constructs one Service with deps.
+func NewService(deps Dependencies) (*Service, error) {
+	if deps.Games == nil {
+		return nil, errors.New("new manual ready-to-start service: nil game store")
+	}
+	if deps.Memberships == nil {
+		return nil, errors.New("new manual ready-to-start service: nil membership store")
+	}
+	if deps.Invites == nil {
+		return nil, errors.New("new manual ready-to-start service: nil invite store")
+	}
+	if deps.Intents == nil {
+		return nil, errors.New("new manual ready-to-start service: nil intent publisher")
+	}
+
+	clock := deps.Clock
+	if clock == nil {
+		clock = time.Now
+	}
+	logger := deps.Logger
+	if logger == nil {
+		logger = slog.Default()
+	}
+
+	return &Service{
+		games:       deps.Games,
+		memberships: deps.Memberships,
+		invites:     deps.Invites,
+		intents:     deps.Intents,
+		clock:       clock,
+		logger:      logger.With("service", "lobby.manualreadytostart"),
+		telemetry:   deps.Telemetry,
+	}, nil
+}
+
+// Input stores the arguments required to manually close enrollment on one
+// game.
+type Input struct {
+	// Actor identifies the caller.
+	Actor shared.Actor
+
+	// GameID identifies the target game record.
+	GameID common.GameID
+}
+
+// Handle authorizes the actor, checks status and roster preconditions,
+// performs the enrollment close (transition + invite expiry +
+// notifications), and returns the post-transition snapshot.
+func (service *Service) Handle(ctx context.Context, input Input) (game.Game, error) {
+	if service == nil {
+		return game.Game{}, errors.New("manual ready-to-start: nil service")
+	}
+	if ctx == nil {
+		return game.Game{}, errors.New("manual ready-to-start: nil context")
+	}
+	if err := input.Actor.Validate(); err != nil {
+		return game.Game{}, fmt.Errorf("manual ready-to-start: actor: %w", err)
+	}
+	if err := input.GameID.Validate(); err != nil {
+		return game.Game{}, fmt.Errorf("manual ready-to-start: %w", err)
+	}
+
+	record, err := service.games.Get(ctx, input.GameID)
+	if err != nil {
+		return game.Game{}, fmt.Errorf("manual ready-to-start: %w", err)
+	}
+
+	if err := authorize(input.Actor, record); err != nil {
+		return game.Game{}, err
+	}
+
+	if record.Status != game.StatusEnrollmentOpen {
+		return game.Game{}, fmt.Errorf(
+			"manual ready-to-start: status %q is not enrollment_open: %w",
+			record.Status, game.ErrConflict,
+		)
+	}
+
+	approvedCount, err := shared.CountActiveMemberships(ctx, service.memberships, input.GameID)
+	if err != nil {
+		return game.Game{}, fmt.Errorf("manual ready-to-start: %w", err)
+	}
+	if approvedCount < record.MinPlayers {
+		return game.Game{}, fmt.Errorf(
+			"manual ready-to-start: approved_count %d is below min_players %d: %w",
+			approvedCount, record.MinPlayers, game.ErrConflict,
+		)
+	}
+
+	at := service.clock().UTC()
+	updated, err := shared.CloseEnrollment(ctx, shared.CloseEnrollmentDeps{
+		Games:     service.games,
+		Invites:   service.invites,
+		Intents:   service.intents,
+		Logger:    service.logger,
+		Telemetry: service.telemetry,
+	}, input.GameID, game.TriggerManual, at)
+	if err != nil {
+		return game.Game{}, fmt.Errorf("manual ready-to-start: %w", err)
+	}
+
+	logArgs := []any{
+		"game_id", updated.GameID.String(),
+		"from_status", string(game.StatusEnrollmentOpen),
+		"to_status", string(updated.Status),
+		"trigger", string(game.TriggerManual),
+		"approved_count", approvedCount,
+		"actor_kind", string(input.Actor.Kind),
+	}
+	logArgs = append(logArgs, logging.ContextAttrs(ctx)...)
+	service.logger.InfoContext(ctx, "game manually moved to ready_to_start", logArgs...)
+
+	return updated, nil
+}
+
+// authorize enforces admin OR private-owner access to the record.
+func authorize(actor shared.Actor, record game.Game) error {
+	if actor.IsAdmin() {
+		return nil
+	}
+	if record.GameType == game.GameTypePrivate && actor.UserID == record.OwnerUserID {
+		return nil
+	}
+	return fmt.Errorf("%w: actor is not authorized to close enrollment on game %q",
+		shared.ErrForbidden, record.GameID.String())
+}
@@ -0,0 +1,250 @@
+package manualreadytostart_test
+
+import (
+	"context"
+	"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/service/manualreadytostart"
+	"galaxy/lobby/internal/service/shared"
+	"galaxy/notificationintent"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+const (
+	publicGameID  = common.GameID("game-public")
+	privateGameID = common.GameID("game-private")
+	ownerUserID   = "user-owner"
+)
+
+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 fixture struct {
+	now         time.Time
+	games       *gamestub.Store
+	invites     *invitestub.Store
+	memberships *membershipstub.Store
+	intents     *intentpubstub.Publisher
+}
+
+func newFixture(t *testing.T) *fixture {
+	t.Helper()
+	now := time.Date(2026, 4, 25, 10, 0, 0, 0, time.UTC)
+	return &fixture{
+		now:         now,
+		games:       gamestub.NewStore(),
+		invites:     invitestub.NewStore(),
+		memberships: membershipstub.NewStore(),
+		intents:     intentpubstub.NewPublisher(),
+	}
+}
+
+func (f *fixture) addGame(t *testing.T, gameID common.GameID, gameType game.GameType, owner string, minPlayers int) game.Game {
+	t.Helper()
+	rec, err := game.New(game.NewGameInput{
+		GameID:              gameID,
+		GameName:            "Test Game",
+		GameType:            gameType,
+		OwnerUserID:         owner,
+		MinPlayers:          minPlayers,
+		MaxPlayers:          minPlayers + 2,
+		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)
+	rec.Status = game.StatusEnrollmentOpen
+	require.NoError(t, f.games.Save(context.Background(), rec))
+	return rec
+}
+
+func (f *fixture) addActiveMember(t *testing.T, membershipID common.MembershipID, gameID common.GameID, userID string) {
+	t.Helper()
+	mem, err := membership.New(membership.NewMembershipInput{
+		MembershipID: membershipID,
+		GameID:       gameID,
+		UserID:       userID,
+		RaceName:     "Race " + userID,
+		CanonicalKey: "race-" + userID,
+		Now:          f.now,
+	})
+	require.NoError(t, err)
+	require.NoError(t, f.memberships.Save(context.Background(), mem))
+}
+
+func (f *fixture) addCreatedInvite(t *testing.T, inviteID common.InviteID, gameID common.GameID, owner, invitee string) {
+	t.Helper()
+	rec, err := invite.New(invite.NewInviteInput{
+		InviteID:      inviteID,
+		GameID:        gameID,
+		InviterUserID: owner,
+		InviteeUserID: invitee,
+		Now:           f.now,
+		ExpiresAt:     f.now.Add(24 * time.Hour),
+	})
+	require.NoError(t, err)
+	require.NoError(t, f.invites.Save(context.Background(), rec))
+}
+
+func (f *fixture) newService(t *testing.T) *manualreadytostart.Service {
+	t.Helper()
+	svc, err := manualreadytostart.NewService(manualreadytostart.Dependencies{
+		Games:       f.games,
+		Memberships: f.memberships,
+		Invites:     f.invites,
+		Intents:     f.intents,
+		Clock:       fixedClock(f.now),
+		Logger:      silentLogger(),
+	})
+	require.NoError(t, err)
+	return svc
+}
+
+func TestHandleAdminClosesPublicEnrollment(t *testing.T) {
+	t.Parallel()
+	f := newFixture(t)
+	f.addGame(t, publicGameID, game.GameTypePublic, "", 2)
+	f.addActiveMember(t, "membership-1", publicGameID, "user-a")
+	f.addActiveMember(t, "membership-2", publicGameID, "user-b")
+
+	got, err := f.newService(t).Handle(context.Background(), manualreadytostart.Input{
+		Actor:  shared.NewAdminActor(),
+		GameID: publicGameID,
+	})
+	require.NoError(t, err)
+	assert.Equal(t, game.StatusReadyToStart, got.Status)
+}
+
+func TestHandleOwnerClosesPrivateEnrollmentAndExpiresInvites(t *testing.T) {
+	t.Parallel()
+	f := newFixture(t)
+	f.addGame(t, privateGameID, game.GameTypePrivate, ownerUserID, 2)
+	f.addActiveMember(t, "membership-1", privateGameID, "user-a")
+	f.addActiveMember(t, "membership-2", privateGameID, "user-b")
+	f.addCreatedInvite(t, "invite-1", privateGameID, ownerUserID, "user-c")
+	f.addCreatedInvite(t, "invite-2", privateGameID, ownerUserID, "user-d")
+
+	got, err := f.newService(t).Handle(context.Background(), manualreadytostart.Input{
+		Actor:  shared.NewUserActor(ownerUserID),
+		GameID: privateGameID,
+	})
+	require.NoError(t, err)
+	assert.Equal(t, game.StatusReadyToStart, got.Status)
+
+	for _, id := range []common.InviteID{"invite-1", "invite-2"} {
+		rec, err := f.invites.Get(context.Background(), id)
+		require.NoError(t, err)
+		assert.Equal(t, invite.StatusExpired, rec.Status)
+	}
+
+	intents := f.intents.Published()
+	require.Len(t, intents, 2)
+	for _, intent := range intents {
+		assert.Equal(t, notificationintent.NotificationTypeLobbyInviteExpired, intent.NotificationType)
+		assert.Equal(t, []string{ownerUserID}, intent.RecipientUserIDs)
+	}
+}
+
+func TestHandleNonOwnerOnPrivateForbidden(t *testing.T) {
+	t.Parallel()
+	f := newFixture(t)
+	f.addGame(t, privateGameID, game.GameTypePrivate, ownerUserID, 2)
+	f.addActiveMember(t, "membership-1", privateGameID, "user-a")
+	f.addActiveMember(t, "membership-2", privateGameID, "user-b")
+
+	_, err := f.newService(t).Handle(context.Background(), manualreadytostart.Input{
+		Actor:  shared.NewUserActor("user-impostor"),
+		GameID: privateGameID,
+	})
+	require.ErrorIs(t, err, shared.ErrForbidden)
+}
+
+func TestHandleUserOnPublicForbidden(t *testing.T) {
+	t.Parallel()
+	f := newFixture(t)
+	f.addGame(t, publicGameID, game.GameTypePublic, "", 2)
+	f.addActiveMember(t, "membership-1", publicGameID, "user-a")
+	f.addActiveMember(t, "membership-2", publicGameID, "user-b")
+
+	_, err := f.newService(t).Handle(context.Background(), manualreadytostart.Input{
+		Actor:  shared.NewUserActor("user-a"),
+		GameID: publicGameID,
+	})
+	require.ErrorIs(t, err, shared.ErrForbidden)
+}
+
+func TestHandleGameNotFound(t *testing.T) {
+	t.Parallel()
+	f := newFixture(t)
+
+	_, err := f.newService(t).Handle(context.Background(), manualreadytostart.Input{
+		Actor:  shared.NewAdminActor(),
+		GameID: publicGameID,
+	})
+	require.ErrorIs(t, err, game.ErrNotFound)
+}
+
+func TestHandleStatusNotEnrollmentOpenConflict(t *testing.T) {
+	t.Parallel()
+	f := newFixture(t)
+	rec := f.addGame(t, publicGameID, game.GameTypePublic, "", 2)
+	rec.Status = game.StatusDraft
+	require.NoError(t, f.games.Save(context.Background(), rec))
+
+	_, err := f.newService(t).Handle(context.Background(), manualreadytostart.Input{
+		Actor:  shared.NewAdminActor(),
+		GameID: publicGameID,
+	})
+	require.ErrorIs(t, err, game.ErrConflict)
+}
+
+func TestHandleBelowMinPlayersConflict(t *testing.T) {
+	t.Parallel()
+	f := newFixture(t)
+	f.addGame(t, publicGameID, game.GameTypePublic, "", 3)
+	f.addActiveMember(t, "membership-1", publicGameID, "user-a")
+	f.addActiveMember(t, "membership-2", publicGameID, "user-b")
+
+	_, err := f.newService(t).Handle(context.Background(), manualreadytostart.Input{
+		Actor:  shared.NewAdminActor(),
+		GameID: publicGameID,
+	})
+	require.ErrorIs(t, err, game.ErrConflict)
+
+	current, err := f.games.Get(context.Background(), publicGameID)
+	require.NoError(t, err)
+	assert.Equal(t, game.StatusEnrollmentOpen, current.Status)
+	assert.Empty(t, f.intents.Published())
+}
+
+func TestHandleEmptyInvitesProducesNoNotifications(t *testing.T) {
+	t.Parallel()
+	f := newFixture(t)
+	f.addGame(t, privateGameID, game.GameTypePrivate, ownerUserID, 2)
+	f.addActiveMember(t, "membership-1", privateGameID, "user-a")
+	f.addActiveMember(t, "membership-2", privateGameID, "user-b")
+
+	_, err := f.newService(t).Handle(context.Background(), manualreadytostart.Input{
+		Actor:  shared.NewUserActor(ownerUserID),
+		GameID: privateGameID,
+	})
+	require.NoError(t, err)
+	assert.Empty(t, f.intents.Published())
+}