feat: game lobby service

lobby/internal/worker/enrollmentautomation/worker.go

@@ -0,0 +1,263 @@
+// Package enrollmentautomation implements the periodic worker that
+// transitions games from `enrollment_open` to `ready_to_start` along the
+// three automatic paths frozen in lobby/README.md §Enrollment Rules:
+// deadline, gap window time exhaustion, and gap window roster
+// exhaustion. The same enrollment-close pipeline that
+// service/manualreadytostart calls is reused via shared.CloseEnrollment
+// so manual and automatic closes stay aligned.
+package enrollmentautomation
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log/slog"
+	"time"
+
+	"galaxy/lobby/internal/domain/game"
+	"galaxy/lobby/internal/logging"
+	"galaxy/lobby/internal/ports"
+	"galaxy/lobby/internal/service/shared"
+	"galaxy/lobby/internal/telemetry"
+)
+
+// Dependencies groups the collaborators consumed by Worker. The struct
+// mirrors the shape used by Lobby services: each store / publisher port
+// is supplied explicitly so wiring stays a single concrete-adapter site.
+type Dependencies struct {
+	// Games is scanned once per tick for records in
+	// game.StatusEnrollmentOpen.
+	Games ports.GameStore
+
+	// Memberships supplies the active-membership count used to evaluate
+	// the deadline and gap-roster preconditions.
+	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
+
+	// GapStore exposes the gap-window activation timestamp recorded by
+	// approveapplication and redeeminvite. It must implement the Get
+	// accessor introduced in the
+	GapStore ports.GapActivationStore
+
+	// Interval controls the tick cadence. It must be positive.
+	Interval time.Duration
+
+	// Clock supplies the wall-clock used for the per-tick "now"
+	// reference and for the close timestamp. Defaults to time.Now when
+	// nil.
+	Clock func() time.Time
+
+	// Logger receives structured worker-level events. Defaults to
+	// slog.Default when nil.
+	Logger *slog.Logger
+
+	// Telemetry records the `lobby.enrollment_automation.checks`
+	// counter per inspected game per tick and forwards into
+	// shared.CloseEnrollment for the `lobby.game.transitions` and
+	// `lobby.invite.outcomes` counters. Optional; nil disables metric
+	// emission.
+	Telemetry *telemetry.Runtime
+}
+
+// Worker drives the periodic enrollment-automation loop.
+type Worker struct {
+	games       ports.GameStore
+	memberships ports.MembershipStore
+	invites     ports.InviteStore
+	intents     ports.IntentPublisher
+	gapStore    ports.GapActivationStore
+	interval    time.Duration
+	clock       func() time.Time
+	logger      *slog.Logger
+	telemetry   *telemetry.Runtime
+}
+
+// NewWorker constructs one Worker from deps.
+func NewWorker(deps Dependencies) (*Worker, error) {
+	if deps.Games == nil {
+		return nil, errors.New("new enrollment automation worker: nil game store")
+	}
+	if deps.Memberships == nil {
+		return nil, errors.New("new enrollment automation worker: nil membership store")
+	}
+	if deps.Invites == nil {
+		return nil, errors.New("new enrollment automation worker: nil invite store")
+	}
+	if deps.Intents == nil {
+		return nil, errors.New("new enrollment automation worker: nil intent publisher")
+	}
+	if deps.GapStore == nil {
+		return nil, errors.New("new enrollment automation worker: nil gap activation store")
+	}
+	if deps.Interval <= 0 {
+		return nil, fmt.Errorf("new enrollment automation worker: interval must be positive, got %s", deps.Interval)
+	}
+
+	clock := deps.Clock
+	if clock == nil {
+		clock = time.Now
+	}
+	logger := deps.Logger
+	if logger == nil {
+		logger = slog.Default()
+	}
+
+	return &Worker{
+		games:       deps.Games,
+		memberships: deps.Memberships,
+		invites:     deps.Invites,
+		intents:     deps.Intents,
+		gapStore:    deps.GapStore,
+		interval:    deps.Interval,
+		clock:       clock,
+		logger:      logger.With("worker", "lobby.enrollmentautomation"),
+		telemetry:   deps.Telemetry,
+	}, nil
+}
+
+// Run drives the periodic ticker. It returns when ctx is cancelled. A
+// failure inside one tick does not terminate the loop — every tick logs
+// its outcome and the worker stays alive so subsequent ticks can pick up
+// once the underlying issue clears.
+func (worker *Worker) Run(ctx context.Context) error {
+	if worker == nil {
+		return errors.New("run enrollment automation worker: nil worker")
+	}
+	if ctx == nil {
+		return errors.New("run enrollment automation worker: nil context")
+	}
+	if err := ctx.Err(); err != nil {
+		return err
+	}
+
+	worker.logger.Info("enrollment automation worker started", "interval", worker.interval.String())
+	defer worker.logger.Info("enrollment automation worker stopped")
+
+	ticker := time.NewTicker(worker.interval)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		case <-ticker.C:
+			worker.Tick(ctx)
+		}
+	}
+}
+
+// Shutdown is a no-op: the worker holds no resources beyond its own
+// goroutine, which Run releases on context cancellation.
+func (worker *Worker) Shutdown(ctx context.Context) error {
+	if ctx == nil {
+		return errors.New("shutdown enrollment automation worker: nil context")
+	}
+	return nil
+}
+
+// Tick performs one automation pass over every enrollment_open game. It
+// is exported so tests may drive the loop deterministically without a
+// real ticker. Tick never returns an error; per-game failures are logged
+// and the iteration continues so a single bad record does not block the
+// rest of the roster.
+func (worker *Worker) Tick(ctx context.Context) {
+	if worker == nil || ctx == nil {
+		return
+	}
+
+	now := worker.clock().UTC()
+
+	games, err := worker.games.GetByStatus(ctx, game.StatusEnrollmentOpen)
+	if err != nil {
+		worker.logger.WarnContext(ctx, "list enrollment_open games",
+			"err", err.Error(),
+		)
+		return
+	}
+
+	for _, record := range games {
+		worker.evaluate(ctx, record, now)
+	}
+}
+
+// evaluate inspects one game record and, when one of the three
+// auto-close preconditions holds, performs the enrollment close.
+// Per-record failures are logged and absorbed; they do not propagate to
+// the caller because that would terminate the worker.
+func (worker *Worker) evaluate(ctx context.Context, record game.Game, now time.Time) {
+	approvedCount, err := shared.CountActiveMemberships(ctx, worker.memberships, record.GameID)
+	if err != nil {
+		worker.logger.WarnContext(ctx, "count active memberships",
+			"game_id", record.GameID.String(),
+			"err", err.Error(),
+		)
+		return
+	}
+
+	gapActivatedAt, gapActive, err := worker.gapStore.Get(ctx, record.GameID)
+	if err != nil {
+		worker.logger.WarnContext(ctx, "read gap activation",
+			"game_id", record.GameID.String(),
+			"err", err.Error(),
+		)
+		gapActive = false
+	}
+
+	gapPlayersExhausted := gapActive && approvedCount >= record.MaxPlayers+record.StartGapPlayers
+	gapTimeExhausted := gapActive && !now.Before(gapActivatedAt.Add(time.Duration(record.StartGapHours)*time.Hour))
+	deadlineReady := !now.Before(record.EnrollmentEndsAt) && approvedCount >= record.MinPlayers
+
+	var trigger game.Trigger
+	switch {
+	case gapPlayersExhausted, gapTimeExhausted:
+		trigger = game.TriggerGap
+	case deadlineReady:
+		trigger = game.TriggerDeadline
+	default:
+		worker.telemetry.RecordEnrollmentAutomationCheck(ctx, "no_op")
+		return
+	}
+
+	updated, err := shared.CloseEnrollment(ctx, shared.CloseEnrollmentDeps{
+		Games:     worker.games,
+		Invites:   worker.invites,
+		Intents:   worker.intents,
+		Logger:    worker.logger,
+		Telemetry: worker.telemetry,
+	}, record.GameID, trigger, now)
+	if err != nil {
+		if errors.Is(err, game.ErrConflict) {
+			worker.telemetry.RecordEnrollmentAutomationCheck(ctx, "no_op")
+			worker.logger.InfoContext(ctx, "skipped game closed by another path",
+				"game_id", record.GameID.String(),
+				"trigger", string(trigger),
+			)
+			return
+		}
+		worker.logger.WarnContext(ctx, "close enrollment",
+			"game_id", record.GameID.String(),
+			"trigger", string(trigger),
+			"err", err.Error(),
+		)
+		return
+	}
+
+	worker.telemetry.RecordEnrollmentAutomationCheck(ctx, "transitioned")
+
+	logArgs := []any{
+		"game_id", updated.GameID.String(),
+		"from_status", string(game.StatusEnrollmentOpen),
+		"to_status", string(updated.Status),
+		"trigger", string(trigger),
+		"approved_count", approvedCount,
+	}
+	logArgs = append(logArgs, logging.ContextAttrs(ctx)...)
+	worker.logger.InfoContext(ctx, "game moved to ready_to_start", logArgs...)
+}

lobby/internal/worker/enrollmentautomation/worker_test.go

@@ -0,0 +1,282 @@
+package enrollmentautomation_test
+
+import (
+	"context"
+	"io"
+	"log/slog"
+	"testing"
+	"time"
+
+	"galaxy/lobby/internal/adapters/gamestub"
+	"galaxy/lobby/internal/adapters/gapactivationstub"
+	"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/worker/enrollmentautomation"
+	"galaxy/notificationintent"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+const (
+	gameID      = 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
+	gapStore    *gapactivationstub.Store
+	intents     *intentpubstub.Publisher
+	game        game.Game
+}
+
+type fixtureOptions struct {
+	minPlayers       int
+	maxPlayers       int
+	startGapHours    int
+	startGapPlayers  int
+	enrollmentEndsAt time.Time
+}
+
+func newFixture(t *testing.T, opts fixtureOptions) *fixture {
+	t.Helper()
+	now := time.Date(2026, 4, 25, 10, 0, 0, 0, time.UTC)
+	if opts.minPlayers == 0 {
+		opts.minPlayers = 2
+	}
+	if opts.maxPlayers == 0 {
+		opts.maxPlayers = 4
+	}
+	if opts.startGapHours == 0 {
+		opts.startGapHours = 2
+	}
+	if opts.startGapPlayers == 0 {
+		opts.startGapPlayers = 1
+	}
+	if opts.enrollmentEndsAt.IsZero() {
+		opts.enrollmentEndsAt = now.Add(24 * time.Hour)
+	}
+
+	rec, err := game.New(game.NewGameInput{
+		GameID:              gameID,
+		GameName:            "Friends Only",
+		GameType:            game.GameTypePrivate,
+		OwnerUserID:         ownerUserID,
+		MinPlayers:          opts.minPlayers,
+		MaxPlayers:          opts.maxPlayers,
+		StartGapHours:       opts.startGapHours,
+		StartGapPlayers:     opts.startGapPlayers,
+		EnrollmentEndsAt:    opts.enrollmentEndsAt,
+		TurnSchedule:        "0 */6 * * *",
+		TargetEngineVersion: "1.0.0",
+		Now:                 now,
+	})
+	require.NoError(t, err)
+	rec.Status = game.StatusEnrollmentOpen
+
+	games := gamestub.NewStore()
+	require.NoError(t, games.Save(context.Background(), rec))
+
+	return &fixture{
+		now:         now,
+		games:       games,
+		invites:     invitestub.NewStore(),
+		memberships: membershipstub.NewStore(),
+		gapStore:    gapactivationstub.NewStore(),
+		intents:     intentpubstub.NewPublisher(),
+		game:        rec,
+	}
+}
+
+func (f *fixture) addActiveMember(t *testing.T, membershipID common.MembershipID, 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, invitee string) {
+	t.Helper()
+	rec, err := invite.New(invite.NewInviteInput{
+		InviteID:      inviteID,
+		GameID:        gameID,
+		InviterUserID: ownerUserID,
+		InviteeUserID: invitee,
+		Now:           f.now,
+		ExpiresAt:     f.game.EnrollmentEndsAt,
+	})
+	require.NoError(t, err)
+	require.NoError(t, f.invites.Save(context.Background(), rec))
+}
+
+func (f *fixture) markGapActivatedAt(t *testing.T, at time.Time) {
+	t.Helper()
+	require.NoError(t, f.gapStore.MarkActivated(context.Background(), gameID, at))
+}
+
+func (f *fixture) newWorker(t *testing.T, tickAt time.Time) *enrollmentautomation.Worker {
+	t.Helper()
+	worker, err := enrollmentautomation.NewWorker(enrollmentautomation.Dependencies{
+		Games:       f.games,
+		Memberships: f.memberships,
+		Invites:     f.invites,
+		Intents:     f.intents,
+		GapStore:    f.gapStore,
+		Interval:    time.Minute,
+		Clock:       fixedClock(tickAt),
+		Logger:      silentLogger(),
+	})
+	require.NoError(t, err)
+	return worker
+}
+
+func currentStatus(t *testing.T, f *fixture) game.Status {
+	t.Helper()
+	rec, err := f.games.Get(context.Background(), gameID)
+	require.NoError(t, err)
+	return rec.Status
+}
+
+func TestNewWorkerRejectsZeroInterval(t *testing.T) {
+	t.Parallel()
+	_, err := enrollmentautomation.NewWorker(enrollmentautomation.Dependencies{
+		Games:       gamestub.NewStore(),
+		Memberships: membershipstub.NewStore(),
+		Invites:     invitestub.NewStore(),
+		Intents:     intentpubstub.NewPublisher(),
+		GapStore:    gapactivationstub.NewStore(),
+		Interval:    0,
+	})
+	require.Error(t, err)
+}
+
+func TestTickDeadlineTriggers(t *testing.T) {
+	t.Parallel()
+	f := newFixture(t, fixtureOptions{minPlayers: 2})
+	f.addActiveMember(t, "membership-1", "user-a")
+	f.addActiveMember(t, "membership-2", "user-b")
+	f.addCreatedInvite(t, "invite-1", "user-c")
+
+	tickAt := f.game.EnrollmentEndsAt.Add(time.Minute)
+	f.newWorker(t, tickAt).Tick(context.Background())
+
+	assert.Equal(t, game.StatusReadyToStart, currentStatus(t, f))
+
+	expired, err := f.invites.Get(context.Background(), "invite-1")
+	require.NoError(t, err)
+	assert.Equal(t, invite.StatusExpired, expired.Status)
+
+	intents := f.intents.Published()
+	require.Len(t, intents, 1)
+	assert.Equal(t, notificationintent.NotificationTypeLobbyInviteExpired, intents[0].NotificationType)
+}
+
+func TestTickDeadlineSkipsBelowMinPlayers(t *testing.T) {
+	t.Parallel()
+	f := newFixture(t, fixtureOptions{minPlayers: 3})
+	f.addActiveMember(t, "membership-1", "user-a")
+	f.addActiveMember(t, "membership-2", "user-b")
+
+	tickAt := f.game.EnrollmentEndsAt.Add(time.Minute)
+	f.newWorker(t, tickAt).Tick(context.Background())
+
+	assert.Equal(t, game.StatusEnrollmentOpen, currentStatus(t, f))
+	assert.Empty(t, f.intents.Published())
+}
+
+func TestTickGapTimeTriggers(t *testing.T) {
+	t.Parallel()
+	f := newFixture(t, fixtureOptions{minPlayers: 2, maxPlayers: 4, startGapHours: 2, startGapPlayers: 2})
+	f.addActiveMember(t, "membership-1", "user-a")
+	f.addActiveMember(t, "membership-2", "user-b")
+	f.addActiveMember(t, "membership-3", "user-c")
+	f.addActiveMember(t, "membership-4", "user-d")
+	f.markGapActivatedAt(t, f.now)
+
+	tickAt := f.now.Add(2 * time.Hour).Add(time.Minute)
+	f.newWorker(t, tickAt).Tick(context.Background())
+
+	assert.Equal(t, game.StatusReadyToStart, currentStatus(t, f))
+}
+
+func TestTickGapPlayersTriggersBeforeTime(t *testing.T) {
+	t.Parallel()
+	f := newFixture(t, fixtureOptions{minPlayers: 2, maxPlayers: 4, startGapHours: 24, startGapPlayers: 1})
+	f.addActiveMember(t, "membership-1", "user-a")
+	f.addActiveMember(t, "membership-2", "user-b")
+	f.addActiveMember(t, "membership-3", "user-c")
+	f.addActiveMember(t, "membership-4", "user-d")
+	f.addActiveMember(t, "membership-5", "user-e")
+	f.markGapActivatedAt(t, f.now)
+
+	tickAt := f.now.Add(15 * time.Minute)
+	f.newWorker(t, tickAt).Tick(context.Background())
+
+	assert.Equal(t, game.StatusReadyToStart, currentStatus(t, f))
+}
+
+func TestTickGapInactiveSkipsBeforeDeadline(t *testing.T) {
+	t.Parallel()
+	f := newFixture(t, fixtureOptions{minPlayers: 2, maxPlayers: 4, startGapHours: 1})
+	f.addActiveMember(t, "membership-1", "user-a")
+	f.addActiveMember(t, "membership-2", "user-b")
+
+	tickAt := f.now.Add(2 * time.Hour)
+	f.newWorker(t, tickAt).Tick(context.Background())
+
+	assert.Equal(t, game.StatusEnrollmentOpen, currentStatus(t, f))
+}
+
+func TestTickIsIdempotent(t *testing.T) {
+	t.Parallel()
+	f := newFixture(t, fixtureOptions{minPlayers: 2})
+	f.addActiveMember(t, "membership-1", "user-a")
+	f.addActiveMember(t, "membership-2", "user-b")
+	f.addCreatedInvite(t, "invite-1", "user-c")
+
+	tickAt := f.game.EnrollmentEndsAt.Add(time.Minute)
+	worker := f.newWorker(t, tickAt)
+
+	worker.Tick(context.Background())
+	worker.Tick(context.Background())
+
+	assert.Equal(t, game.StatusReadyToStart, currentStatus(t, f))
+	assert.Len(t, f.intents.Published(), 1)
+}
+
+func TestRunStopsOnContextCancel(t *testing.T) {
+	t.Parallel()
+	f := newFixture(t, fixtureOptions{minPlayers: 2})
+	worker := f.newWorker(t, f.now)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	done := make(chan error, 1)
+	go func() { done <- worker.Run(ctx) }()
+	cancel()
+
+	select {
+	case err := <-done:
+		require.ErrorIs(t, err, context.Canceled)
+	case <-time.After(time.Second):
+		t.Fatal("worker did not stop after context cancel")
+	}
+}