Files

213 lines
5.7 KiB
Go

package store
import (
"context"
"encoding/json"
"os"
"path/filepath"
"slices"
"sync"
"testing"
"time"
"aeternalis/server/content"
"aeternalis/server/internal/game"
p "aeternalis/server/internal/protocol"
)
func TestStoreLifecycle(t *testing.T) {
runStoreTests(t, "file:"+filepath.ToSlash(filepath.Join(t.TempDir(), "world.db")))
}
func TestConcurrentPassageRedemption(t *testing.T) {
ctx := context.Background()
db, err := Open(ctx, "file:"+filepath.ToSlash(filepath.Join(t.TempDir(), "race.db")))
if err != nil {
t.Fatal(err)
}
defer db.Close()
b, _ := content.Load()
now := time.Now().UTC()
source := game.New("source", 1, now, b)
lease, _, err := db.Acquire(ctx, source)
if err != nil {
t.Fatal(err)
}
c, _ := source.Join("account", "Survivor")
c.View.Entity.State = "eligible"
source.Phase = "won"
if err = lease.Save(ctx, source, ""); err != nil {
t.Fatal(err)
}
targets := []*game.World{game.New("target-a", 2, now, b), game.New("target-b", 3, now, b)}
leases := make([]*Lease, 2)
for i, w := range targets {
leases[i], _, err = db.Acquire(ctx, w)
if err != nil {
t.Fatal(err)
}
copy, err := db.ReadPassage(ctx, c.View.Entity.ID, c.Account)
if err != nil {
t.Fatal(err)
}
if err = w.Import(copy); err != nil {
t.Fatal(err)
}
}
var wg sync.WaitGroup
results := make(chan error, 2)
for i := range targets {
wg.Add(1)
go func(i int) { defer wg.Done(); results <- leases[i].Save(ctx, targets[i], c.View.Entity.ID) }(i)
}
wg.Wait()
close(results)
successes := 0
for err := range results {
if err == nil {
successes++
}
}
if successes != 1 {
t.Fatalf("expected one successful redemption, got %d", successes)
}
durableCopies := 0
for _, w := range targets {
var raw string
if err := db.sql.QueryRowContext(ctx, db.q("SELECT snapshot FROM worlds WHERE id=?"), w.ID).Scan(&raw); err != nil {
t.Fatal(err)
}
var restored game.World
if err := json.Unmarshal([]byte(raw), &restored); err != nil {
t.Fatal(err)
}
if restored.Characters[c.View.Entity.ID] != nil {
durableCopies++
}
}
if durableCopies != 1 {
t.Fatal("failed redemption left a durable duplicate")
}
}
func TestPostgresLifecycle(t *testing.T) {
dsn := os.Getenv("TEST_DATABASE_URL")
if dsn == "" {
t.Skip("TEST_DATABASE_URL not configured")
}
runStoreTests(t, dsn)
}
func runStoreTests(t *testing.T, dsn string) {
ctx := context.Background()
db, err := Open(ctx, dsn)
if err != nil {
t.Fatal(err)
}
defer db.Close()
balance, _ := content.Load()
prefix := game.ID()
now := time.Now().UTC()
source := game.New(prefix+"-source", 123, now, balance)
lease, _, err := db.Acquire(ctx, source)
if err != nil {
t.Fatal(err)
}
if _, _, err = db.Acquire(ctx, source); err == nil {
t.Fatal("two simultaneous world owners")
}
c, _ := source.Join("account:"+prefix, "Traveler")
c.View.Inventory["spear"] = 1
c.DailySeconds = 123
c.View.Entity.State = "eligible"
source.Phase = "won"
if err = lease.Save(ctx, source, ""); err != nil {
t.Fatal(err)
}
if err = lease.Save(ctx, source, ""); err != nil {
t.Fatal(err)
}
passages, err := db.Passages(ctx, c.Account)
if err != nil || len(passages) != 1 {
t.Fatalf("idempotent survivor grant %v %v", passages, err)
}
if _, err = db.ReadPassage(ctx, c.View.Entity.ID, "attacker"); err == nil {
t.Fatal("another account stole transfer")
}
target := game.New(prefix+"-target", 456, now, balance)
targetLease, _, err := db.Acquire(ctx, target)
if err != nil {
t.Fatal(err)
}
survivor, err := db.ReadPassage(ctx, c.View.Entity.ID, c.Account)
if err != nil {
t.Fatal(err)
}
if err = target.Import(survivor); err != nil {
t.Fatal(err)
}
if err = targetLease.Save(ctx, target, c.View.Entity.ID); err != nil {
t.Fatal(err)
}
if _, err = db.ReadPassage(ctx, c.View.Entity.ID, c.Account); err == nil {
t.Fatal("passage can be redeemed twice")
}
third := game.New(prefix+"-third", 789, now, balance)
thirdLease, _, err := db.Acquire(ctx, third)
if err != nil {
t.Fatal(err)
}
copy := *survivor
copy.View.Entity.State = "eligible"
if err = third.Import(&copy); err != nil {
t.Fatal(err)
}
if err = thirdLease.Save(ctx, third, c.View.Entity.ID); err == nil {
t.Fatal("duplicate transfer committed")
}
if err = targetLease.Release(ctx); err != nil {
t.Fatal(err)
}
freshLease, raw, err := db.Acquire(ctx, target)
if err != nil {
t.Fatal(err)
}
var restored game.World
if err = json.Unmarshal(raw, &restored); err != nil {
t.Fatal(err)
}
loaded := restored.Characters[c.View.Entity.ID]
if loaded == nil || loaded.DailySeconds != 123 || !slices.ContainsFunc(loaded.View.Items, func(item p.ItemInstance) bool { return item.DefinitionID == "spear" }) {
t.Fatal("transfer not durable")
}
if err = targetLease.Save(ctx, target, ""); err == nil {
t.Fatal("stale owner wrote state")
}
// A subsequent victory grants a fresh passage for the same permanent character ID.
loaded.View.Entity.State = "eligible"
restored.Phase = "won"
if err = freshLease.Save(ctx, &restored, ""); err != nil {
t.Fatal(err)
}
if err = lease.Save(ctx, source, ""); err != nil {
t.Fatal(err)
}
passages, err = db.Passages(ctx, c.Account)
if err != nil || len(passages) != 1 || passages[0].SourceWorld != target.ID {
t.Fatal("old world overwrote next passage")
}
if err = db.CreateSession(ctx, "hash:"+prefix, c.Account); err != nil {
t.Fatal(err)
}
if account, err := db.Session(ctx, "hash:"+prefix); err != nil || account != c.Account {
t.Fatal("session roundtrip")
}
if err = db.DeleteSession(ctx, "hash:"+prefix); err != nil {
t.Fatal(err)
}
if _, err = db.Session(ctx, "hash:"+prefix); err == nil {
t.Fatal("revoked session remains valid")
}
_ = lease.Release(ctx)
_ = freshLease.Release(ctx)
_ = thirdLease.Release(ctx)
}