Ilia Denisov
410 lines
13 KiB
Go
410 lines
13 KiB
Go
package registerracename_test
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"io"
|
|
"log/slog"
|
|
"testing"
|
|
"time"
|
|
|
|
"galaxy/lobby/internal/adapters/intentpubstub"
|
|
"galaxy/lobby/internal/adapters/racenamestub"
|
|
"galaxy/lobby/internal/adapters/userservicestub"
|
|
"galaxy/lobby/internal/ports"
|
|
"galaxy/lobby/internal/service/registerracename"
|
|
"galaxy/lobby/internal/service/shared"
|
|
"galaxy/notificationintent"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
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
|
|
directory *racenamestub.Directory
|
|
users *userservicestub.Service
|
|
intents *intentpubstub.Publisher
|
|
}
|
|
|
|
func newFixture(t *testing.T, now time.Time) *fixture {
|
|
t.Helper()
|
|
directory, err := racenamestub.NewDirectory(racenamestub.WithClock(fixedClock(now)))
|
|
require.NoError(t, err)
|
|
return &fixture{
|
|
now: now,
|
|
directory: directory,
|
|
users: userservicestub.NewService(),
|
|
intents: intentpubstub.NewPublisher(),
|
|
}
|
|
}
|
|
|
|
func (f *fixture) newService(t *testing.T) *registerracename.Service {
|
|
t.Helper()
|
|
svc, err := registerracename.NewService(registerracename.Dependencies{
|
|
Directory: f.directory,
|
|
Users: f.users,
|
|
Intents: f.intents,
|
|
Clock: fixedClock(f.now),
|
|
Logger: silentLogger(),
|
|
})
|
|
require.NoError(t, err)
|
|
return svc
|
|
}
|
|
|
|
// seedPending creates a pending_registration for (gameID, userID,
|
|
// raceName) with eligibleUntil. It mirrors the production sequence
|
|
// (Reserve at approve-time, MarkPendingRegistration at game finish).
|
|
func (f *fixture) seedPending(
|
|
t *testing.T,
|
|
gameID, userID, raceName string,
|
|
eligibleUntil time.Time,
|
|
) {
|
|
t.Helper()
|
|
require.NoError(t, f.directory.Reserve(context.Background(), gameID, userID, raceName))
|
|
require.NoError(t, f.directory.MarkPendingRegistration(context.Background(), gameID, userID, raceName, eligibleUntil))
|
|
}
|
|
|
|
// seedRegistered creates an existing registered entry by walking through
|
|
// the full Reserve → MarkPending → Register flow. It is used to grow the
|
|
// `len(registered)` for quota tests.
|
|
func (f *fixture) seedRegistered(t *testing.T, gameID, userID, raceName string) {
|
|
t.Helper()
|
|
eligibleUntil := f.now.Add(24 * time.Hour)
|
|
f.seedPending(t, gameID, userID, raceName, eligibleUntil)
|
|
require.NoError(t, f.directory.Register(context.Background(), gameID, userID, raceName))
|
|
}
|
|
|
|
func defaultEligibility(maxRegistered int) ports.Eligibility {
|
|
return ports.Eligibility{
|
|
Exists: true,
|
|
CanLogin: true,
|
|
CanJoinGame: true,
|
|
CanUpdateProfile: true,
|
|
MaxRegisteredRaceNames: maxRegistered,
|
|
}
|
|
}
|
|
|
|
func TestNewServiceRejectsMissingDeps(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
_, err := registerracename.NewService(registerracename.Dependencies{})
|
|
require.Error(t, err)
|
|
}
|
|
|
|
func TestRegisterRaceNameHappyPath(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
now := time.Date(2026, 4, 25, 12, 0, 0, 0, time.UTC)
|
|
f := newFixture(t, now)
|
|
f.users.SetEligibility("user-1", defaultEligibility(2))
|
|
f.seedPending(t, "game-1", "user-1", "Stellaris", now.Add(7*24*time.Hour))
|
|
|
|
svc := f.newService(t)
|
|
out, err := svc.Handle(context.Background(), registerracename.Input{
|
|
Actor: shared.NewUserActor("user-1"),
|
|
SourceGameID: "game-1",
|
|
RaceName: "Stellaris",
|
|
})
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "game-1", out.SourceGameID)
|
|
assert.Equal(t, "Stellaris", out.RaceName)
|
|
expectedCanonical, err := f.directory.Canonicalize("Stellaris")
|
|
require.NoError(t, err)
|
|
assert.Equal(t, expectedCanonical, out.CanonicalKey)
|
|
assert.Equal(t, now.UnixMilli(), out.RegisteredAtMs)
|
|
|
|
registered, err := f.directory.ListRegistered(context.Background(), "user-1")
|
|
require.NoError(t, err)
|
|
require.Len(t, registered, 1)
|
|
assert.Equal(t, "game-1", registered[0].SourceGameID)
|
|
|
|
pending, err := f.directory.ListPendingRegistrations(context.Background(), "user-1")
|
|
require.NoError(t, err)
|
|
assert.Empty(t, pending)
|
|
|
|
intents := f.intents.Published()
|
|
require.Len(t, intents, 1)
|
|
intent := intents[0]
|
|
assert.Equal(t, notificationintent.NotificationTypeLobbyRaceNameRegistered, intent.NotificationType)
|
|
require.Equal(t, []string{"user-1"}, intent.RecipientUserIDs)
|
|
assert.Equal(t, "lobby.race_name.registered:game-1:user-1", intent.IdempotencyKey)
|
|
var payload notificationintent.LobbyRaceNameRegisteredPayload
|
|
require.NoError(t, json.Unmarshal([]byte(intent.PayloadJSON), &payload))
|
|
assert.Equal(t, "Stellaris", payload.RaceName)
|
|
}
|
|
|
|
func TestRegisterRaceNameIdempotentRetry(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
now := time.Date(2026, 4, 25, 12, 0, 0, 0, time.UTC)
|
|
f := newFixture(t, now)
|
|
f.users.SetEligibility("user-1", defaultEligibility(1))
|
|
f.seedPending(t, "game-1", "user-1", "Stellaris", now.Add(7*24*time.Hour))
|
|
|
|
svc := f.newService(t)
|
|
first, err := svc.Handle(context.Background(), registerracename.Input{
|
|
Actor: shared.NewUserActor("user-1"),
|
|
SourceGameID: "game-1",
|
|
RaceName: "Stellaris",
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
second, err := svc.Handle(context.Background(), registerracename.Input{
|
|
Actor: shared.NewUserActor("user-1"),
|
|
SourceGameID: "game-1",
|
|
RaceName: "Stellaris",
|
|
})
|
|
require.NoError(t, err)
|
|
assert.Equal(t, first, second)
|
|
|
|
registered, err := f.directory.ListRegistered(context.Background(), "user-1")
|
|
require.NoError(t, err)
|
|
assert.Len(t, registered, 1, "registration must remain idempotent")
|
|
|
|
intents := f.intents.Published()
|
|
require.Len(t, intents, 2, "idempotent retry republishes the intent")
|
|
for _, intent := range intents {
|
|
assert.Equal(t, "lobby.race_name.registered:game-1:user-1", intent.IdempotencyKey)
|
|
}
|
|
}
|
|
|
|
func TestRegisterRaceNameRejectsAdminActor(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
now := time.Date(2026, 4, 25, 12, 0, 0, 0, time.UTC)
|
|
f := newFixture(t, now)
|
|
|
|
svc := f.newService(t)
|
|
_, err := svc.Handle(context.Background(), registerracename.Input{
|
|
Actor: shared.NewAdminActor(),
|
|
SourceGameID: "game-1",
|
|
RaceName: "Stellaris",
|
|
})
|
|
require.ErrorIs(t, err, shared.ErrForbidden)
|
|
}
|
|
|
|
func TestRegisterRaceNameRejectsInvalidActor(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
now := time.Date(2026, 4, 25, 12, 0, 0, 0, time.UTC)
|
|
f := newFixture(t, now)
|
|
|
|
svc := f.newService(t)
|
|
_, err := svc.Handle(context.Background(), registerracename.Input{
|
|
Actor: shared.Actor{Kind: shared.ActorKindUser},
|
|
SourceGameID: "game-1",
|
|
RaceName: "Stellaris",
|
|
})
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), "actor")
|
|
}
|
|
|
|
func TestRegisterRaceNameRejectsEmptyRaceName(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
now := time.Date(2026, 4, 25, 12, 0, 0, 0, time.UTC)
|
|
f := newFixture(t, now)
|
|
|
|
svc := f.newService(t)
|
|
_, err := svc.Handle(context.Background(), registerracename.Input{
|
|
Actor: shared.NewUserActor("user-1"),
|
|
SourceGameID: "game-1",
|
|
RaceName: " ",
|
|
})
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), "must not be empty")
|
|
}
|
|
|
|
func TestRegisterRaceNameRejectsInvalidName(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
now := time.Date(2026, 4, 25, 12, 0, 0, 0, time.UTC)
|
|
f := newFixture(t, now)
|
|
|
|
svc := f.newService(t)
|
|
_, err := svc.Handle(context.Background(), registerracename.Input{
|
|
Actor: shared.NewUserActor("user-1"),
|
|
SourceGameID: "game-1",
|
|
// "<>" fails ValidateTypeName.
|
|
RaceName: "<>",
|
|
})
|
|
require.ErrorIs(t, err, ports.ErrInvalidName)
|
|
}
|
|
|
|
func TestRegisterRaceNameRejectsUnknownUser(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
now := time.Date(2026, 4, 25, 12, 0, 0, 0, time.UTC)
|
|
f := newFixture(t, now)
|
|
|
|
svc := f.newService(t)
|
|
_, err := svc.Handle(context.Background(), registerracename.Input{
|
|
Actor: shared.NewUserActor("user-ghost"),
|
|
SourceGameID: "game-1",
|
|
RaceName: "Stellaris",
|
|
})
|
|
require.ErrorIs(t, err, shared.ErrSubjectNotFound)
|
|
}
|
|
|
|
func TestRegisterRaceNameRejectsPermanentBlock(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
now := time.Date(2026, 4, 25, 12, 0, 0, 0, time.UTC)
|
|
f := newFixture(t, now)
|
|
f.users.SetEligibility("user-1", ports.Eligibility{
|
|
Exists: true,
|
|
PermanentBlocked: true,
|
|
MaxRegisteredRaceNames: 2,
|
|
})
|
|
f.seedPending(t, "game-1", "user-1", "Stellaris", now.Add(7*24*time.Hour))
|
|
|
|
svc := f.newService(t)
|
|
_, err := svc.Handle(context.Background(), registerracename.Input{
|
|
Actor: shared.NewUserActor("user-1"),
|
|
SourceGameID: "game-1",
|
|
RaceName: "Stellaris",
|
|
})
|
|
require.ErrorIs(t, err, shared.ErrForbidden)
|
|
}
|
|
|
|
func TestRegisterRaceNamePendingMissing(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
now := time.Date(2026, 4, 25, 12, 0, 0, 0, time.UTC)
|
|
f := newFixture(t, now)
|
|
f.users.SetEligibility("user-1", defaultEligibility(2))
|
|
|
|
svc := f.newService(t)
|
|
_, err := svc.Handle(context.Background(), registerracename.Input{
|
|
Actor: shared.NewUserActor("user-1"),
|
|
SourceGameID: "game-1",
|
|
RaceName: "Stellaris",
|
|
})
|
|
require.ErrorIs(t, err, ports.ErrPendingMissing)
|
|
}
|
|
|
|
func TestRegisterRaceNamePendingForOtherUserSurfacesAsMissing(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
now := time.Date(2026, 4, 25, 12, 0, 0, 0, time.UTC)
|
|
f := newFixture(t, now)
|
|
f.users.SetEligibility("user-1", defaultEligibility(2))
|
|
// Pending exists for a different user; the actor has none.
|
|
f.seedPending(t, "game-1", "user-other", "Stellaris", now.Add(24*time.Hour))
|
|
|
|
svc := f.newService(t)
|
|
_, err := svc.Handle(context.Background(), registerracename.Input{
|
|
Actor: shared.NewUserActor("user-1"),
|
|
SourceGameID: "game-1",
|
|
RaceName: "Stellaris",
|
|
})
|
|
// A pending entry held by a different user is reported as missing
|
|
// for the actor: only registered names by another user surface as
|
|
// ErrNameTaken on Register (see racenamedir.go port comment and
|
|
// the Redis adapter behaviour).
|
|
require.ErrorIs(t, err, ports.ErrPendingMissing)
|
|
}
|
|
|
|
func TestRegisterRaceNamePendingExpired(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
now := time.Date(2026, 4, 25, 12, 0, 0, 0, time.UTC)
|
|
f := newFixture(t, now)
|
|
f.users.SetEligibility("user-1", defaultEligibility(2))
|
|
// Pending elig until is in the past relative to now.
|
|
f.seedPending(t, "game-1", "user-1", "Stellaris", now.Add(-time.Minute))
|
|
|
|
svc := f.newService(t)
|
|
_, err := svc.Handle(context.Background(), registerracename.Input{
|
|
Actor: shared.NewUserActor("user-1"),
|
|
SourceGameID: "game-1",
|
|
RaceName: "Stellaris",
|
|
})
|
|
require.ErrorIs(t, err, ports.ErrPendingExpired)
|
|
}
|
|
|
|
func TestRegisterRaceNameQuotaExceeded(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
now := time.Date(2026, 4, 25, 12, 0, 0, 0, time.UTC)
|
|
f := newFixture(t, now)
|
|
// Free-tier quota = 1; user already has one registered name.
|
|
f.users.SetEligibility("user-1", defaultEligibility(1))
|
|
f.seedRegistered(t, "game-existing", "user-1", "OldName")
|
|
f.seedPending(t, "game-new", "user-1", "Stellaris", now.Add(24*time.Hour))
|
|
|
|
svc := f.newService(t)
|
|
_, err := svc.Handle(context.Background(), registerracename.Input{
|
|
Actor: shared.NewUserActor("user-1"),
|
|
SourceGameID: "game-new",
|
|
RaceName: "Stellaris",
|
|
})
|
|
require.ErrorIs(t, err, ports.ErrQuotaExceeded)
|
|
}
|
|
|
|
func TestRegisterRaceNameUnlimitedQuotaAllowsManyRegistrations(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
now := time.Date(2026, 4, 25, 12, 0, 0, 0, time.UTC)
|
|
f := newFixture(t, now)
|
|
// MaxRegisteredRaceNames=0 marker → unlimited.
|
|
f.users.SetEligibility("user-1", defaultEligibility(0))
|
|
f.seedRegistered(t, "game-a", "user-1", "First")
|
|
f.seedRegistered(t, "game-b", "user-1", "Second")
|
|
f.seedPending(t, "game-c", "user-1", "Third", now.Add(24*time.Hour))
|
|
|
|
svc := f.newService(t)
|
|
_, err := svc.Handle(context.Background(), registerracename.Input{
|
|
Actor: shared.NewUserActor("user-1"),
|
|
SourceGameID: "game-c",
|
|
RaceName: "Third",
|
|
})
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
func TestRegisterRaceNameUserServiceUnavailable(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
now := time.Date(2026, 4, 25, 12, 0, 0, 0, time.UTC)
|
|
f := newFixture(t, now)
|
|
f.users.SetFailure("user-1", ports.ErrUserServiceUnavailable)
|
|
f.seedPending(t, "game-1", "user-1", "Stellaris", now.Add(24*time.Hour))
|
|
|
|
svc := f.newService(t)
|
|
_, err := svc.Handle(context.Background(), registerracename.Input{
|
|
Actor: shared.NewUserActor("user-1"),
|
|
SourceGameID: "game-1",
|
|
RaceName: "Stellaris",
|
|
})
|
|
require.ErrorIs(t, err, ports.ErrUserServiceUnavailable)
|
|
}
|
|
|
|
func TestRegisterRaceNameCommitsEvenIfPublishFails(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
now := time.Date(2026, 4, 25, 12, 0, 0, 0, time.UTC)
|
|
f := newFixture(t, now)
|
|
f.users.SetEligibility("user-1", defaultEligibility(2))
|
|
f.seedPending(t, "game-1", "user-1", "Stellaris", now.Add(7*24*time.Hour))
|
|
f.intents.SetError(errors.New("notification stream unavailable"))
|
|
|
|
svc := f.newService(t)
|
|
out, err := svc.Handle(context.Background(), registerracename.Input{
|
|
Actor: shared.NewUserActor("user-1"),
|
|
SourceGameID: "game-1",
|
|
RaceName: "Stellaris",
|
|
})
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "Stellaris", out.RaceName)
|
|
|
|
registered, err := f.directory.ListRegistered(context.Background(), "user-1")
|
|
require.NoError(t, err)
|
|
require.Len(t, registered, 1)
|
|
}
|