feat: use postgres

2026-04-26 20:34:39 +02:00
parent 48b0056b49
commit fe829285a6
365 changed files with 29223 additions and 24049 deletions
@@ -0,0 +1,213 @@
+package membershipstore_test
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"galaxy/lobby/internal/adapters/postgres/gamestore"
+	"galaxy/lobby/internal/adapters/postgres/internal/pgtest"
+	"galaxy/lobby/internal/adapters/postgres/membershipstore"
+	"galaxy/lobby/internal/domain/common"
+	"galaxy/lobby/internal/domain/game"
+	"galaxy/lobby/internal/domain/membership"
+	"galaxy/lobby/internal/ports"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestMain(m *testing.M) { pgtest.RunMain(m) }
+
+func newStores(t *testing.T) (*gamestore.Store, *membershipstore.Store) {
+	t.Helper()
+	pgtest.TruncateAll(t)
+	gs, err := gamestore.New(gamestore.Config{
+		DB: pgtest.Ensure(t).Pool(), OperationTimeout: pgtest.OperationTimeout,
+	})
+	require.NoError(t, err)
+	ms, err := membershipstore.New(membershipstore.Config{
+		DB: pgtest.Ensure(t).Pool(), OperationTimeout: pgtest.OperationTimeout,
+	})
+	require.NoError(t, err)
+	return gs, ms
+}
+
+func seedGame(t *testing.T, gs *gamestore.Store, id string) game.Game {
+	t.Helper()
+	now := time.Date(2026, 4, 23, 12, 0, 0, 0, time.UTC)
+	g, err := game.New(game.NewGameInput{
+		GameID:              common.GameID(id),
+		GameName:            "G " + id,
+		GameType:            game.GameTypePublic,
+		MinPlayers:          2,
+		MaxPlayers:          8,
+		StartGapHours:       12,
+		StartGapPlayers:     2,
+		EnrollmentEndsAt:    now.Add(7 * 24 * time.Hour),
+		TurnSchedule:        "0 18 * * *",
+		TargetEngineVersion: "v1.0.0",
+		Now:                 now,
+	})
+	require.NoError(t, err)
+	require.NoError(t, gs.Save(context.Background(), g))
+	return g
+}
+
+func newMembership(t *testing.T, id, gameID, userID, race, canon string) membership.Membership {
+	t.Helper()
+	now := time.Date(2026, 4, 23, 12, 0, 0, 0, time.UTC)
+	rec, err := membership.New(membership.NewMembershipInput{
+		MembershipID: common.MembershipID(id),
+		GameID:       common.GameID(gameID),
+		UserID:       userID,
+		RaceName:     race,
+		CanonicalKey: canon,
+		Now:          now,
+	})
+	require.NoError(t, err)
+	return rec
+}
+
+func TestSaveAndGet(t *testing.T) {
+	ctx := context.Background()
+	gs, ms := newStores(t)
+	seedGame(t, gs, "game-001")
+
+	rec := newMembership(t, "membership-001", "game-001", "user-a", "Pilot Alpha", "pilot-alpha")
+	require.NoError(t, ms.Save(ctx, rec))
+
+	got, err := ms.Get(ctx, rec.MembershipID)
+	require.NoError(t, err)
+	assert.Equal(t, rec.MembershipID, got.MembershipID)
+	assert.Equal(t, "Pilot Alpha", got.RaceName)
+	assert.Equal(t, "pilot-alpha", got.CanonicalKey)
+	assert.Equal(t, membership.StatusActive, got.Status)
+	assert.Nil(t, got.RemovedAt)
+}
+
+func TestSaveRejectsNonActive(t *testing.T) {
+	ctx := context.Background()
+	gs, ms := newStores(t)
+	seedGame(t, gs, "game-001")
+
+	rec := newMembership(t, "membership-001", "game-001", "user-a", "Pilot", "pilot")
+	rec.Status = membership.StatusRemoved
+	require.Error(t, ms.Save(ctx, rec))
+}
+
+func TestSaveDuplicateReturnsConflict(t *testing.T) {
+	ctx := context.Background()
+	gs, ms := newStores(t)
+	seedGame(t, gs, "game-001")
+
+	rec := newMembership(t, "membership-001", "game-001", "user-a", "Pilot", "pilot")
+	require.NoError(t, ms.Save(ctx, rec))
+	err := ms.Save(ctx, rec)
+	require.ErrorIs(t, err, membership.ErrConflict)
+}
+
+func TestUpdateStatusToRemovedSetsRemovedAt(t *testing.T) {
+	ctx := context.Background()
+	gs, ms := newStores(t)
+	seedGame(t, gs, "game-001")
+
+	rec := newMembership(t, "membership-001", "game-001", "user-a", "Pilot", "pilot")
+	require.NoError(t, ms.Save(ctx, rec))
+	at := rec.JoinedAt.Add(time.Minute)
+	require.NoError(t, ms.UpdateStatus(ctx, ports.UpdateMembershipStatusInput{
+		MembershipID: rec.MembershipID,
+		ExpectedFrom: membership.StatusActive,
+		To:           membership.StatusRemoved,
+		At:           at,
+	}))
+	got, err := ms.Get(ctx, rec.MembershipID)
+	require.NoError(t, err)
+	assert.Equal(t, membership.StatusRemoved, got.Status)
+	require.NotNil(t, got.RemovedAt)
+	assert.True(t, got.RemovedAt.Equal(at))
+}
+
+func TestUpdateStatusReturnsConflictOnExpectedFromMismatch(t *testing.T) {
+	ctx := context.Background()
+	gs, ms := newStores(t)
+	seedGame(t, gs, "game-001")
+
+	rec := newMembership(t, "membership-001", "game-001", "user-a", "Pilot", "pilot")
+	require.NoError(t, ms.Save(ctx, rec))
+
+	// Move the row out of `active` first; the next attempt's
+	// `WHERE status = 'active'` then fails on persistence even though
+	// (active → blocked) is itself a valid transition in the domain table.
+	require.NoError(t, ms.UpdateStatus(ctx, ports.UpdateMembershipStatusInput{
+		MembershipID: rec.MembershipID,
+		ExpectedFrom: membership.StatusActive,
+		To:           membership.StatusRemoved,
+		At:           rec.JoinedAt.Add(time.Minute),
+	}))
+	err := ms.UpdateStatus(ctx, ports.UpdateMembershipStatusInput{
+		MembershipID: rec.MembershipID,
+		ExpectedFrom: membership.StatusActive,
+		To:           membership.StatusBlocked,
+		At:           rec.JoinedAt.Add(2 * time.Minute),
+	})
+	require.ErrorIs(t, err, membership.ErrConflict)
+}
+
+func TestUpdateStatusReturnsNotFoundForMissing(t *testing.T) {
+	ctx := context.Background()
+	_, ms := newStores(t)
+	err := ms.UpdateStatus(ctx, ports.UpdateMembershipStatusInput{
+		MembershipID: common.MembershipID("membership-missing"),
+		ExpectedFrom: membership.StatusActive,
+		To:           membership.StatusRemoved,
+		At:           time.Now().UTC(),
+	})
+	require.ErrorIs(t, err, membership.ErrNotFound)
+}
+
+func TestDeleteRemovesRecord(t *testing.T) {
+	ctx := context.Background()
+	gs, ms := newStores(t)
+	seedGame(t, gs, "game-001")
+
+	rec := newMembership(t, "membership-001", "game-001", "user-a", "Pilot", "pilot")
+	require.NoError(t, ms.Save(ctx, rec))
+	require.NoError(t, ms.Delete(ctx, rec.MembershipID))
+
+	_, err := ms.Get(ctx, rec.MembershipID)
+	require.ErrorIs(t, err, membership.ErrNotFound)
+}
+
+func TestDeleteReturnsNotFoundForMissing(t *testing.T) {
+	ctx := context.Background()
+	_, ms := newStores(t)
+	err := ms.Delete(ctx, common.MembershipID("membership-missing"))
+	require.ErrorIs(t, err, membership.ErrNotFound)
+}
+
+func TestGetByGameAndUser(t *testing.T) {
+	ctx := context.Background()
+	gs, ms := newStores(t)
+	seedGame(t, gs, "game-001")
+	seedGame(t, gs, "game-002")
+
+	require.NoError(t, ms.Save(ctx, newMembership(t, "membership-001", "game-001", "user-a", "P-a", "p-a")))
+	require.NoError(t, ms.Save(ctx, newMembership(t, "membership-002", "game-001", "user-b", "P-b", "p-b")))
+	require.NoError(t, ms.Save(ctx, newMembership(t, "membership-003", "game-002", "user-a", "P-a2", "p-a2")))
+
+	g1, err := ms.GetByGame(ctx, common.GameID("game-001"))
+	require.NoError(t, err)
+	assert.Len(t, g1, 2)
+
+	userA, err := ms.GetByUser(ctx, "user-a")
+	require.NoError(t, err)
+	assert.Len(t, userA, 2)
+}
+
+func TestGetMissingReturnsNotFound(t *testing.T) {
+	ctx := context.Background()
+	_, ms := newStores(t)
+	_, err := ms.Get(ctx, common.MembershipID("membership-missing"))
+	require.ErrorIs(t, err, membership.ErrNotFound)
+}