galaxy-game/lobby/internal/adapters/postgres/membershipstore/store_test.go

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)
}