303 lines
10 KiB
Go
303 lines
10 KiB
Go
//go:build integration
|
|
|
|
package inttest
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
|
|
"scrabble/backend/internal/account"
|
|
"scrabble/backend/internal/accountmerge"
|
|
"scrabble/backend/internal/engine"
|
|
"scrabble/backend/internal/game"
|
|
"scrabble/backend/internal/link"
|
|
"scrabble/backend/internal/session"
|
|
)
|
|
|
|
// --- merge test helpers ---
|
|
|
|
func setStats(t *testing.T, id uuid.UUID, w, l, d, mg, mw int) {
|
|
t.Helper()
|
|
if _, err := testDB.ExecContext(context.Background(),
|
|
`INSERT INTO backend.account_stats (account_id, wins, losses, draws, max_game_points, max_word_points)
|
|
VALUES ($1,$2,$3,$4,$5,$6)
|
|
ON CONFLICT (account_id) DO UPDATE SET wins=$2, losses=$3, draws=$4, max_game_points=$5, max_word_points=$6`,
|
|
id, w, l, d, mg, mw); err != nil {
|
|
t.Fatalf("set stats: %v", err)
|
|
}
|
|
}
|
|
|
|
func setWallet(t *testing.T, id uuid.UUID, hints int, paid bool) {
|
|
t.Helper()
|
|
if _, err := testDB.ExecContext(context.Background(),
|
|
`UPDATE backend.accounts SET hint_balance=$2, paid_account=$3 WHERE account_id=$1`, id, hints, paid); err != nil {
|
|
t.Fatalf("set wallet: %v", err)
|
|
}
|
|
}
|
|
|
|
func bindEmailIdentity(t *testing.T, acc uuid.UUID, email string) {
|
|
t.Helper()
|
|
if _, err := testDB.ExecContext(context.Background(),
|
|
`INSERT INTO backend.identities (identity_id, account_id, kind, external_id, confirmed) VALUES ($1,$2,'email',$3,true)`,
|
|
uuid.New(), acc, email); err != nil {
|
|
t.Fatalf("bind email identity: %v", err)
|
|
}
|
|
}
|
|
|
|
func insertFriendship(t *testing.T, a, b uuid.UUID, status string) {
|
|
t.Helper()
|
|
if _, err := testDB.ExecContext(context.Background(),
|
|
`INSERT INTO backend.friendships (requester_id, addressee_id, status) VALUES ($1,$2,$3)`, a, b, status); err != nil {
|
|
t.Fatalf("insert friendship: %v", err)
|
|
}
|
|
}
|
|
|
|
func mergedInto(t *testing.T, id uuid.UUID) uuid.UUID {
|
|
t.Helper()
|
|
var into *uuid.UUID
|
|
if err := testDB.QueryRowContext(context.Background(),
|
|
`SELECT merged_into FROM backend.accounts WHERE account_id=$1`, id).Scan(&into); err != nil {
|
|
t.Fatalf("read merged_into: %v", err)
|
|
}
|
|
if into == nil {
|
|
return uuid.Nil
|
|
}
|
|
return *into
|
|
}
|
|
|
|
func seatCount(t *testing.T, gameID, accountID uuid.UUID) int {
|
|
t.Helper()
|
|
var n int
|
|
if err := testDB.QueryRowContext(context.Background(),
|
|
`SELECT count(*) FROM backend.game_players WHERE game_id=$1 AND account_id=$2`, gameID, accountID).Scan(&n); err != nil {
|
|
t.Fatalf("seat count: %v", err)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func seatGame(t *testing.T, seats []uuid.UUID, timeout time.Duration) uuid.UUID {
|
|
t.Helper()
|
|
g, err := newGameService().Create(context.Background(), game.CreateParams{
|
|
Variant: engine.VariantEnglish, Seats: seats, TurnTimeout: timeout, Seed: openingSeed(t),
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("seat game: %v", err)
|
|
}
|
|
return g.ID
|
|
}
|
|
|
|
func newLinkService(mailer account.Mailer) *link.Service {
|
|
store := account.NewStore(testDB)
|
|
emails := account.NewEmailService(store, mailer)
|
|
sessions := session.NewService(session.NewStore(testDB), session.NewCache())
|
|
return link.NewService(emails, store, accountmerge.NewMerger(testDB), sessions)
|
|
}
|
|
|
|
// TestAccountMergeCore folds every account-scoped artifact of a secondary into a
|
|
// primary: stats summed, wallet summed, paid flag ORed, identity repointed, a
|
|
// non-shared game transferred, a friend carried over, and the secondary tombstoned.
|
|
func TestAccountMergeCore(t *testing.T) {
|
|
ctx := context.Background()
|
|
store := account.NewStore(testDB)
|
|
merger := accountmerge.NewMerger(testDB)
|
|
|
|
primary := provisionAccount(t)
|
|
secondary := provisionAccount(t)
|
|
friend := provisionAccount(t)
|
|
|
|
setStats(t, primary, 1, 0, 0, 100, 90)
|
|
setStats(t, secondary, 3, 1, 2, 400, 80)
|
|
setWallet(t, primary, 2, false)
|
|
setWallet(t, secondary, 5, true)
|
|
|
|
email := "merge-" + uuid.NewString() + "@example.com"
|
|
bindEmailIdentity(t, secondary, email)
|
|
insertFriendship(t, secondary, friend, "accepted")
|
|
gameID := seatGame(t, []uuid.UUID{secondary, friend}, 24*time.Hour)
|
|
|
|
if err := merger.Merge(ctx, primary, secondary); err != nil {
|
|
t.Fatalf("merge: %v", err)
|
|
}
|
|
|
|
w, l, d, mg, mw, found := readStats(t, primary)
|
|
if !found || w != 4 || l != 1 || d != 2 || mg != 400 || mw != 90 {
|
|
t.Errorf("primary stats = (%d,%d,%d,%d,%d found=%v), want (4,1,2,400,90 true)", w, l, d, mg, mw, found)
|
|
}
|
|
if _, _, _, _, _, found := readStats(t, secondary); found {
|
|
t.Error("secondary stats row should be deleted after merge")
|
|
}
|
|
|
|
acc, err := store.GetByID(ctx, primary)
|
|
if err != nil {
|
|
t.Fatalf("get primary: %v", err)
|
|
}
|
|
if acc.HintBalance != 7 {
|
|
t.Errorf("hint balance = %d, want 7", acc.HintBalance)
|
|
}
|
|
if !acc.PaidAccount {
|
|
t.Error("paid_account should be true (ORed from secondary)")
|
|
}
|
|
|
|
if owner, ok, _ := store.AccountIDByIdentity(ctx, account.KindEmail, email); !ok || owner != primary {
|
|
t.Errorf("email owner = %s ok=%v, want primary %s", owner, ok, primary)
|
|
}
|
|
if seatCount(t, gameID, primary) != 1 || seatCount(t, gameID, secondary) != 0 {
|
|
t.Error("non-shared game seat should transfer to primary")
|
|
}
|
|
if friends, _ := newSocialService().ListFriends(ctx, primary); len(friends) != 1 || friends[0] != friend {
|
|
t.Errorf("primary friends = %v, want [%s]", friends, friend)
|
|
}
|
|
if mergedInto(t, secondary) != primary {
|
|
t.Errorf("secondary.merged_into = %s, want primary %s", mergedInto(t, secondary), primary)
|
|
}
|
|
}
|
|
|
|
// TestAccountMergeActiveGameConflict refuses a merge when the two share an active
|
|
// game (one player cannot be merged against themselves).
|
|
func TestAccountMergeActiveGameConflict(t *testing.T) {
|
|
ctx := context.Background()
|
|
merger := accountmerge.NewMerger(testDB)
|
|
primary := provisionAccount(t)
|
|
secondary := provisionAccount(t)
|
|
seatGame(t, []uuid.UUID{primary, secondary}, 24*time.Hour)
|
|
|
|
if err := merger.Merge(ctx, primary, secondary); err != accountmerge.ErrActiveGameConflict {
|
|
t.Fatalf("merge = %v, want ErrActiveGameConflict", err)
|
|
}
|
|
if mergedInto(t, secondary) != uuid.Nil {
|
|
t.Error("a refused merge must not tombstone the secondary")
|
|
}
|
|
}
|
|
|
|
// TestAccountMergeFinishedSharedGameKept allows a merge when the shared game is
|
|
// finished and leaves the secondary's seat in place (the tombstone keeps the
|
|
// no-cascade foreign key valid).
|
|
func TestAccountMergeFinishedSharedGameKept(t *testing.T) {
|
|
ctx := context.Background()
|
|
merger := accountmerge.NewMerger(testDB)
|
|
primary := provisionAccount(t)
|
|
secondary := provisionAccount(t)
|
|
gameID := seatGame(t, []uuid.UUID{primary, secondary}, 24*time.Hour)
|
|
if _, err := testDB.ExecContext(ctx, `UPDATE backend.games SET status='finished' WHERE game_id=$1`, gameID); err != nil {
|
|
t.Fatalf("finish game: %v", err)
|
|
}
|
|
|
|
if err := merger.Merge(ctx, primary, secondary); err != nil {
|
|
t.Fatalf("merge: %v", err)
|
|
}
|
|
if seatCount(t, gameID, primary) != 1 || seatCount(t, gameID, secondary) != 1 {
|
|
t.Error("a shared finished game must keep both seats (secondary as tombstone)")
|
|
}
|
|
if mergedInto(t, secondary) != primary {
|
|
t.Error("secondary should be tombstoned")
|
|
}
|
|
}
|
|
|
|
// TestAccountLinkFreeEmail binds a free email and promotes a guest to durable.
|
|
func TestAccountLinkFreeEmail(t *testing.T) {
|
|
ctx := context.Background()
|
|
store := account.NewStore(testDB)
|
|
mailer := &capturingMailer{}
|
|
links := newLinkService(mailer)
|
|
|
|
guest := provisionGuest(t)
|
|
email := "fresh-" + uuid.NewString() + "@example.com"
|
|
if err := links.RequestEmail(ctx, guest, email); err != nil {
|
|
t.Fatalf("request: %v", err)
|
|
}
|
|
res, err := links.ConfirmEmail(ctx, guest, email, sixDigit.FindString(mailer.lastBody))
|
|
if err != nil {
|
|
t.Fatalf("confirm: %v", err)
|
|
}
|
|
if !res.Linked || res.MergeRequired {
|
|
t.Fatalf("confirm = %+v, want linked", res)
|
|
}
|
|
acc, _ := store.GetByID(ctx, guest)
|
|
if acc.IsGuest {
|
|
t.Error("guest flag should clear once an identity is linked")
|
|
}
|
|
if owner, ok, _ := store.AccountIDByIdentity(ctx, account.KindEmail, email); !ok || owner != guest {
|
|
t.Errorf("email owner = %s, want the promoted guest %s", owner, guest)
|
|
}
|
|
}
|
|
|
|
// TestAccountLinkEmailMergeIntoCaller merges the email's owner into the current
|
|
// (durable) account: the caller stays primary and keeps its session.
|
|
func TestAccountLinkEmailMergeIntoCaller(t *testing.T) {
|
|
ctx := context.Background()
|
|
store := account.NewStore(testDB)
|
|
mailer := &capturingMailer{}
|
|
links := newLinkService(mailer)
|
|
|
|
caller := provisionAccount(t)
|
|
other := provisionAccount(t)
|
|
email := "owned-" + uuid.NewString() + "@example.com"
|
|
bindEmailIdentity(t, other, email)
|
|
|
|
if err := links.RequestEmail(ctx, caller, email); err != nil {
|
|
t.Fatalf("request: %v", err)
|
|
}
|
|
code := sixDigit.FindString(mailer.lastBody)
|
|
confirm, err := links.ConfirmEmail(ctx, caller, email, code)
|
|
if err != nil {
|
|
t.Fatalf("confirm: %v", err)
|
|
}
|
|
if !confirm.MergeRequired || confirm.SecondaryID != other {
|
|
t.Fatalf("confirm = %+v, want merge_required to other %s", confirm, other)
|
|
}
|
|
merge, err := links.MergeEmail(ctx, caller, email, code)
|
|
if err != nil {
|
|
t.Fatalf("merge: %v", err)
|
|
}
|
|
if merge.PrimaryID != caller || merge.SwitchedToken != "" {
|
|
t.Fatalf("merge = %+v, want primary caller and no session switch", merge)
|
|
}
|
|
if mergedInto(t, other) != caller {
|
|
t.Error("other should be tombstoned into caller")
|
|
}
|
|
if owner, _, _ := store.AccountIDByIdentity(ctx, account.KindEmail, email); owner != caller {
|
|
t.Errorf("email owner = %s, want caller", owner)
|
|
}
|
|
}
|
|
|
|
// TestAccountLinkGuestInversion merges a guest initiator into the durable account
|
|
// that owns the email: the durable account wins and a fresh session is minted.
|
|
func TestAccountLinkGuestInversion(t *testing.T) {
|
|
ctx := context.Background()
|
|
store := account.NewStore(testDB)
|
|
mailer := &capturingMailer{}
|
|
links := newLinkService(mailer)
|
|
|
|
durable := provisionAccount(t)
|
|
email := "durable-" + uuid.NewString() + "@example.com"
|
|
bindEmailIdentity(t, durable, email)
|
|
guest := provisionGuest(t)
|
|
|
|
if err := links.RequestEmail(ctx, guest, email); err != nil {
|
|
t.Fatalf("request: %v", err)
|
|
}
|
|
code := sixDigit.FindString(mailer.lastBody)
|
|
if _, err := links.ConfirmEmail(ctx, guest, email, code); err != nil {
|
|
t.Fatalf("confirm: %v", err)
|
|
}
|
|
merge, err := links.MergeEmail(ctx, guest, email, code)
|
|
if err != nil {
|
|
t.Fatalf("merge: %v", err)
|
|
}
|
|
if merge.PrimaryID != durable {
|
|
t.Fatalf("primary = %s, want durable %s", merge.PrimaryID, durable)
|
|
}
|
|
if merge.SwitchedToken == "" {
|
|
t.Error("a guest initiator whose durable counterpart wins must get a switched session token")
|
|
}
|
|
if mergedInto(t, guest) != durable {
|
|
t.Error("the guest should be tombstoned into the durable account")
|
|
}
|
|
if owner, _, _ := store.AccountIDByIdentity(ctx, account.KindEmail, email); owner != durable {
|
|
t.Errorf("email owner = %s, want durable", owner)
|
|
}
|
|
}
|