mirror of
https://github.com/Mezeporta/Erupe.git
synced 2026-03-21 23:22:34 +01:00
ba7ec122f8
An MMO server without multiplayer defeats the purpose. PostgreSQL is the right choice and Docker Compose already solves the setup pain. This reverts the common/db wrapper, SQLite schema, config Driver field, modernc.org/sqlite dependency, and all repo type changes while keeping the dashboard, wizard, and CI improvements from the previous commit.
628 lines
17 KiB
Go
628 lines
17 KiB
Go
package channelserver
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/jmoiron/sqlx"
|
|
)
|
|
|
|
func setupCharRepo(t *testing.T) (*CharacterRepository, *sqlx.DB, uint32) {
|
|
t.Helper()
|
|
db := SetupTestDB(t)
|
|
userID := CreateTestUser(t, db, "repo_test_user")
|
|
charID := CreateTestCharacter(t, db, userID, "RepoChar")
|
|
repo := NewCharacterRepository(db)
|
|
t.Cleanup(func() { TeardownTestDB(t, db) })
|
|
return repo, db, charID
|
|
}
|
|
|
|
func TestLoadColumn(t *testing.T) {
|
|
repo, db, charID := setupCharRepo(t)
|
|
|
|
// Write a known blob to a column
|
|
blob := []byte{0xDE, 0xAD, 0xBE, 0xEF}
|
|
_, err := db.Exec("UPDATE characters SET otomoairou=$1 WHERE id=$2", blob, charID)
|
|
if err != nil {
|
|
t.Fatalf("Setup failed: %v", err)
|
|
}
|
|
|
|
data, err := repo.LoadColumn(charID, "otomoairou")
|
|
if err != nil {
|
|
t.Fatalf("LoadColumn failed: %v", err)
|
|
}
|
|
if len(data) != 4 || data[0] != 0xDE || data[3] != 0xEF {
|
|
t.Errorf("LoadColumn returned unexpected data: %x", data)
|
|
}
|
|
}
|
|
|
|
func TestLoadColumnNil(t *testing.T) {
|
|
repo, _, charID := setupCharRepo(t)
|
|
|
|
// Column should be NULL by default
|
|
data, err := repo.LoadColumn(charID, "otomoairou")
|
|
if err != nil {
|
|
t.Fatalf("LoadColumn failed: %v", err)
|
|
}
|
|
if data != nil {
|
|
t.Errorf("Expected nil for NULL column, got: %x", data)
|
|
}
|
|
}
|
|
|
|
func TestSaveColumn(t *testing.T) {
|
|
repo, db, charID := setupCharRepo(t)
|
|
|
|
blob := []byte{0x01, 0x02, 0x03}
|
|
if err := repo.SaveColumn(charID, "otomoairou", blob); err != nil {
|
|
t.Fatalf("SaveColumn failed: %v", err)
|
|
}
|
|
|
|
// Verify via direct SELECT
|
|
var got []byte
|
|
if err := db.QueryRow("SELECT otomoairou FROM characters WHERE id=$1", charID).Scan(&got); err != nil {
|
|
t.Fatalf("Verification query failed: %v", err)
|
|
}
|
|
if len(got) != 3 || got[0] != 0x01 || got[2] != 0x03 {
|
|
t.Errorf("SaveColumn wrote unexpected data: %x", got)
|
|
}
|
|
}
|
|
|
|
func TestReadInt(t *testing.T) {
|
|
repo, _, charID := setupCharRepo(t)
|
|
|
|
// time_played defaults to 0 via COALESCE
|
|
val, err := repo.ReadInt(charID, "time_played")
|
|
if err != nil {
|
|
t.Fatalf("ReadInt failed: %v", err)
|
|
}
|
|
if val != 0 {
|
|
t.Errorf("Expected 0 for default time_played, got: %d", val)
|
|
}
|
|
}
|
|
|
|
func TestReadIntWithValue(t *testing.T) {
|
|
repo, db, charID := setupCharRepo(t)
|
|
|
|
_, err := db.Exec("UPDATE characters SET time_played=42 WHERE id=$1", charID)
|
|
if err != nil {
|
|
t.Fatalf("Setup failed: %v", err)
|
|
}
|
|
|
|
val, err := repo.ReadInt(charID, "time_played")
|
|
if err != nil {
|
|
t.Fatalf("ReadInt failed: %v", err)
|
|
}
|
|
if val != 42 {
|
|
t.Errorf("Expected 42, got: %d", val)
|
|
}
|
|
}
|
|
|
|
func TestAdjustInt(t *testing.T) {
|
|
repo, _, charID := setupCharRepo(t)
|
|
|
|
// First adjustment from NULL (COALESCE makes it 0 + 10 = 10)
|
|
val, err := repo.AdjustInt(charID, "time_played", 10)
|
|
if err != nil {
|
|
t.Fatalf("AdjustInt failed: %v", err)
|
|
}
|
|
if val != 10 {
|
|
t.Errorf("Expected 10 after first adjust, got: %d", val)
|
|
}
|
|
|
|
// Second adjustment: 10 + 5 = 15
|
|
val, err = repo.AdjustInt(charID, "time_played", 5)
|
|
if err != nil {
|
|
t.Fatalf("AdjustInt failed: %v", err)
|
|
}
|
|
if val != 15 {
|
|
t.Errorf("Expected 15 after second adjust, got: %d", val)
|
|
}
|
|
}
|
|
|
|
func TestGetName(t *testing.T) {
|
|
repo, _, charID := setupCharRepo(t)
|
|
|
|
name, err := repo.GetName(charID)
|
|
if err != nil {
|
|
t.Fatalf("GetName failed: %v", err)
|
|
}
|
|
if name != "RepoChar" {
|
|
t.Errorf("Expected 'RepoChar', got: %q", name)
|
|
}
|
|
}
|
|
|
|
func TestGetUserID(t *testing.T) {
|
|
repo, db, charID := setupCharRepo(t)
|
|
|
|
// Look up the expected user_id
|
|
var expectedUID uint32
|
|
if err := db.QueryRow("SELECT user_id FROM characters WHERE id=$1", charID).Scan(&expectedUID); err != nil {
|
|
t.Fatalf("Setup query failed: %v", err)
|
|
}
|
|
|
|
uid, err := repo.GetUserID(charID)
|
|
if err != nil {
|
|
t.Fatalf("GetUserID failed: %v", err)
|
|
}
|
|
if uid != expectedUID {
|
|
t.Errorf("Expected user_id %d, got: %d", expectedUID, uid)
|
|
}
|
|
}
|
|
|
|
func TestUpdateLastLogin(t *testing.T) {
|
|
repo, db, charID := setupCharRepo(t)
|
|
|
|
ts := int64(1700000000)
|
|
if err := repo.UpdateLastLogin(charID, ts); err != nil {
|
|
t.Fatalf("UpdateLastLogin failed: %v", err)
|
|
}
|
|
|
|
var got int64
|
|
if err := db.QueryRow("SELECT last_login FROM characters WHERE id=$1", charID).Scan(&got); err != nil {
|
|
t.Fatalf("Verification query failed: %v", err)
|
|
}
|
|
if got != ts {
|
|
t.Errorf("Expected last_login %d, got: %d", ts, got)
|
|
}
|
|
}
|
|
|
|
func TestUpdateTimePlayed(t *testing.T) {
|
|
repo, db, charID := setupCharRepo(t)
|
|
|
|
if err := repo.UpdateTimePlayed(charID, 999); err != nil {
|
|
t.Fatalf("UpdateTimePlayed failed: %v", err)
|
|
}
|
|
|
|
var got int
|
|
if err := db.QueryRow("SELECT time_played FROM characters WHERE id=$1", charID).Scan(&got); err != nil {
|
|
t.Fatalf("Verification query failed: %v", err)
|
|
}
|
|
if got != 999 {
|
|
t.Errorf("Expected time_played 999, got: %d", got)
|
|
}
|
|
}
|
|
|
|
func TestGetCharIDsByUserID(t *testing.T) {
|
|
repo, db, _ := setupCharRepo(t)
|
|
|
|
// Create a second user with multiple characters
|
|
uid2 := CreateTestUser(t, db, "multi_char_user")
|
|
cid1 := CreateTestCharacter(t, db, uid2, "Char1")
|
|
cid2 := CreateTestCharacter(t, db, uid2, "Char2")
|
|
|
|
ids, err := repo.GetCharIDsByUserID(uid2)
|
|
if err != nil {
|
|
t.Fatalf("GetCharIDsByUserID failed: %v", err)
|
|
}
|
|
if len(ids) != 2 {
|
|
t.Fatalf("Expected 2 character IDs, got: %d", len(ids))
|
|
}
|
|
|
|
// Check both IDs are present (order may vary)
|
|
found := map[uint32]bool{cid1: false, cid2: false}
|
|
for _, id := range ids {
|
|
found[id] = true
|
|
}
|
|
if !found[cid1] || !found[cid2] {
|
|
t.Errorf("Expected IDs %d and %d, got: %v", cid1, cid2, ids)
|
|
}
|
|
}
|
|
|
|
func TestGetCharIDsByUserIDEmpty(t *testing.T) {
|
|
repo, db, _ := setupCharRepo(t)
|
|
|
|
// Create a user with no characters
|
|
uid := CreateTestUser(t, db, "no_chars_user")
|
|
|
|
ids, err := repo.GetCharIDsByUserID(uid)
|
|
if err != nil {
|
|
t.Fatalf("GetCharIDsByUserID failed: %v", err)
|
|
}
|
|
if len(ids) != 0 {
|
|
t.Errorf("Expected 0 character IDs for user with no chars, got: %d", len(ids))
|
|
}
|
|
}
|
|
|
|
func TestReadTimeNull(t *testing.T) {
|
|
repo, _, charID := setupCharRepo(t)
|
|
|
|
defaultTime := time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)
|
|
got, err := repo.ReadTime(charID, "daily_time", defaultTime)
|
|
if err != nil {
|
|
t.Fatalf("ReadTime failed: %v", err)
|
|
}
|
|
if !got.Equal(defaultTime) {
|
|
t.Errorf("Expected default time %v, got: %v", defaultTime, got)
|
|
}
|
|
}
|
|
|
|
func TestReadTimeWithValue(t *testing.T) {
|
|
repo, db, charID := setupCharRepo(t)
|
|
|
|
expected := time.Date(2025, 6, 15, 12, 0, 0, 0, time.UTC)
|
|
if _, err := db.Exec("UPDATE characters SET daily_time=$1 WHERE id=$2", expected, charID); err != nil {
|
|
t.Fatalf("Setup failed: %v", err)
|
|
}
|
|
|
|
got, err := repo.ReadTime(charID, "daily_time", time.Time{})
|
|
if err != nil {
|
|
t.Fatalf("ReadTime failed: %v", err)
|
|
}
|
|
if !got.Equal(expected) {
|
|
t.Errorf("Expected %v, got: %v", expected, got)
|
|
}
|
|
}
|
|
|
|
func TestSaveTime(t *testing.T) {
|
|
repo, db, charID := setupCharRepo(t)
|
|
|
|
expected := time.Date(2025, 6, 15, 12, 0, 0, 0, time.UTC)
|
|
if err := repo.SaveTime(charID, "daily_time", expected); err != nil {
|
|
t.Fatalf("SaveTime failed: %v", err)
|
|
}
|
|
|
|
var got time.Time
|
|
if err := db.QueryRow("SELECT daily_time FROM characters WHERE id=$1", charID).Scan(&got); err != nil {
|
|
t.Fatalf("Verification query failed: %v", err)
|
|
}
|
|
if !got.Equal(expected) {
|
|
t.Errorf("Expected %v, got: %v", expected, got)
|
|
}
|
|
}
|
|
|
|
func TestSaveInt(t *testing.T) {
|
|
repo, db, charID := setupCharRepo(t)
|
|
|
|
if err := repo.SaveInt(charID, "netcafe_points", 500); err != nil {
|
|
t.Fatalf("SaveInt failed: %v", err)
|
|
}
|
|
|
|
var got int
|
|
if err := db.QueryRow("SELECT netcafe_points FROM characters WHERE id=$1", charID).Scan(&got); err != nil {
|
|
t.Fatalf("Verification query failed: %v", err)
|
|
}
|
|
if got != 500 {
|
|
t.Errorf("Expected 500, got: %d", got)
|
|
}
|
|
}
|
|
|
|
func TestSaveBool(t *testing.T) {
|
|
repo, db, charID := setupCharRepo(t)
|
|
|
|
if err := repo.SaveBool(charID, "restrict_guild_scout", true); err != nil {
|
|
t.Fatalf("SaveBool failed: %v", err)
|
|
}
|
|
|
|
var got bool
|
|
if err := db.QueryRow("SELECT restrict_guild_scout FROM characters WHERE id=$1", charID).Scan(&got); err != nil {
|
|
t.Fatalf("Verification query failed: %v", err)
|
|
}
|
|
if !got {
|
|
t.Errorf("Expected true, got false")
|
|
}
|
|
}
|
|
|
|
func TestReadBool(t *testing.T) {
|
|
repo, db, charID := setupCharRepo(t)
|
|
|
|
if _, err := db.Exec("UPDATE characters SET restrict_guild_scout=true WHERE id=$1", charID); err != nil {
|
|
t.Fatalf("Setup failed: %v", err)
|
|
}
|
|
|
|
got, err := repo.ReadBool(charID, "restrict_guild_scout")
|
|
if err != nil {
|
|
t.Fatalf("ReadBool failed: %v", err)
|
|
}
|
|
if !got {
|
|
t.Errorf("Expected true, got false")
|
|
}
|
|
}
|
|
|
|
func TestSaveString(t *testing.T) {
|
|
repo, db, charID := setupCharRepo(t)
|
|
|
|
if err := repo.SaveString(charID, "friends", "1,2,3"); err != nil {
|
|
t.Fatalf("SaveString failed: %v", err)
|
|
}
|
|
|
|
var got string
|
|
if err := db.QueryRow("SELECT friends FROM characters WHERE id=$1", charID).Scan(&got); err != nil {
|
|
t.Fatalf("Verification query failed: %v", err)
|
|
}
|
|
if got != "1,2,3" {
|
|
t.Errorf("Expected '1,2,3', got: %q", got)
|
|
}
|
|
}
|
|
|
|
func TestReadString(t *testing.T) {
|
|
repo, db, charID := setupCharRepo(t)
|
|
|
|
if _, err := db.Exec("UPDATE characters SET friends='4,5,6' WHERE id=$1", charID); err != nil {
|
|
t.Fatalf("Setup failed: %v", err)
|
|
}
|
|
|
|
got, err := repo.ReadString(charID, "friends")
|
|
if err != nil {
|
|
t.Fatalf("ReadString failed: %v", err)
|
|
}
|
|
if got != "4,5,6" {
|
|
t.Errorf("Expected '4,5,6', got: %q", got)
|
|
}
|
|
}
|
|
|
|
func TestReadStringNull(t *testing.T) {
|
|
repo, _, charID := setupCharRepo(t)
|
|
|
|
got, err := repo.ReadString(charID, "friends")
|
|
if err != nil {
|
|
t.Fatalf("ReadString failed: %v", err)
|
|
}
|
|
if got != "" {
|
|
t.Errorf("Expected empty string for NULL, got: %q", got)
|
|
}
|
|
}
|
|
|
|
func TestLoadColumnWithDefault(t *testing.T) {
|
|
repo, _, charID := setupCharRepo(t)
|
|
|
|
defaultVal := []byte{0x00, 0x01, 0x02}
|
|
got, err := repo.LoadColumnWithDefault(charID, "skin_hist", defaultVal)
|
|
if err != nil {
|
|
t.Fatalf("LoadColumnWithDefault failed: %v", err)
|
|
}
|
|
if len(got) != 3 || got[0] != 0x00 || got[2] != 0x02 {
|
|
t.Errorf("Expected default value, got: %x", got)
|
|
}
|
|
}
|
|
|
|
func TestLoadColumnWithDefaultExistingData(t *testing.T) {
|
|
repo, db, charID := setupCharRepo(t)
|
|
|
|
blob := []byte{0xAA, 0xBB}
|
|
if _, err := db.Exec("UPDATE characters SET skin_hist=$1 WHERE id=$2", blob, charID); err != nil {
|
|
t.Fatalf("Setup failed: %v", err)
|
|
}
|
|
|
|
got, err := repo.LoadColumnWithDefault(charID, "skin_hist", []byte{0x00})
|
|
if err != nil {
|
|
t.Fatalf("LoadColumnWithDefault failed: %v", err)
|
|
}
|
|
if len(got) != 2 || got[0] != 0xAA || got[1] != 0xBB {
|
|
t.Errorf("Expected stored data, got: %x", got)
|
|
}
|
|
}
|
|
|
|
func TestSetDeleted(t *testing.T) {
|
|
repo, db, charID := setupCharRepo(t)
|
|
|
|
if err := repo.SetDeleted(charID); err != nil {
|
|
t.Fatalf("SetDeleted failed: %v", err)
|
|
}
|
|
|
|
var deleted bool
|
|
if err := db.QueryRow("SELECT deleted FROM characters WHERE id=$1", charID).Scan(&deleted); err != nil {
|
|
t.Fatalf("Verification query failed: %v", err)
|
|
}
|
|
if !deleted {
|
|
t.Errorf("Expected deleted=true")
|
|
}
|
|
}
|
|
|
|
func TestUpdateDailyCafe(t *testing.T) {
|
|
repo, db, charID := setupCharRepo(t)
|
|
|
|
dailyTime := time.Date(2025, 6, 15, 12, 0, 0, 0, time.UTC)
|
|
if err := repo.UpdateDailyCafe(charID, dailyTime, 5, 10); err != nil {
|
|
t.Fatalf("UpdateDailyCafe failed: %v", err)
|
|
}
|
|
|
|
var gotTime time.Time
|
|
var bonus, daily uint32
|
|
if err := db.QueryRow("SELECT daily_time, bonus_quests, daily_quests FROM characters WHERE id=$1", charID).Scan(&gotTime, &bonus, &daily); err != nil {
|
|
t.Fatalf("Verification query failed: %v", err)
|
|
}
|
|
if !gotTime.Equal(dailyTime) {
|
|
t.Errorf("Expected daily_time %v, got: %v", dailyTime, gotTime)
|
|
}
|
|
if bonus != 5 || daily != 10 {
|
|
t.Errorf("Expected bonus=5 daily=10, got bonus=%d daily=%d", bonus, daily)
|
|
}
|
|
}
|
|
|
|
func TestResetDailyQuests(t *testing.T) {
|
|
repo, db, charID := setupCharRepo(t)
|
|
|
|
if _, err := db.Exec("UPDATE characters SET bonus_quests=5, daily_quests=10 WHERE id=$1", charID); err != nil {
|
|
t.Fatalf("Setup failed: %v", err)
|
|
}
|
|
|
|
if err := repo.ResetDailyQuests(charID); err != nil {
|
|
t.Fatalf("ResetDailyQuests failed: %v", err)
|
|
}
|
|
|
|
var bonus, daily uint32
|
|
if err := db.QueryRow("SELECT bonus_quests, daily_quests FROM characters WHERE id=$1", charID).Scan(&bonus, &daily); err != nil {
|
|
t.Fatalf("Verification query failed: %v", err)
|
|
}
|
|
if bonus != 0 || daily != 0 {
|
|
t.Errorf("Expected bonus=0 daily=0, got bonus=%d daily=%d", bonus, daily)
|
|
}
|
|
}
|
|
|
|
func TestReadEtcPoints(t *testing.T) {
|
|
repo, db, charID := setupCharRepo(t)
|
|
|
|
if _, err := db.Exec("UPDATE characters SET bonus_quests=3, daily_quests=7, promo_points=100 WHERE id=$1", charID); err != nil {
|
|
t.Fatalf("Setup failed: %v", err)
|
|
}
|
|
|
|
bonus, daily, promo, err := repo.ReadEtcPoints(charID)
|
|
if err != nil {
|
|
t.Fatalf("ReadEtcPoints failed: %v", err)
|
|
}
|
|
if bonus != 3 || daily != 7 || promo != 100 {
|
|
t.Errorf("Expected 3/7/100, got %d/%d/%d", bonus, daily, promo)
|
|
}
|
|
}
|
|
|
|
func TestResetCafeTime(t *testing.T) {
|
|
repo, db, charID := setupCharRepo(t)
|
|
|
|
if _, err := db.Exec("UPDATE characters SET cafe_time=999 WHERE id=$1", charID); err != nil {
|
|
t.Fatalf("Setup failed: %v", err)
|
|
}
|
|
|
|
cafeReset := time.Date(2025, 6, 22, 0, 0, 0, 0, time.UTC)
|
|
if err := repo.ResetCafeTime(charID, cafeReset); err != nil {
|
|
t.Fatalf("ResetCafeTime failed: %v", err)
|
|
}
|
|
|
|
var cafeTime int
|
|
var gotReset time.Time
|
|
if err := db.QueryRow("SELECT cafe_time, cafe_reset FROM characters WHERE id=$1", charID).Scan(&cafeTime, &gotReset); err != nil {
|
|
t.Fatalf("Verification query failed: %v", err)
|
|
}
|
|
if cafeTime != 0 {
|
|
t.Errorf("Expected cafe_time=0, got: %d", cafeTime)
|
|
}
|
|
if !gotReset.Equal(cafeReset) {
|
|
t.Errorf("Expected cafe_reset %v, got: %v", cafeReset, gotReset)
|
|
}
|
|
}
|
|
|
|
func TestUpdateGuildPostChecked(t *testing.T) {
|
|
repo, db, charID := setupCharRepo(t)
|
|
|
|
before := time.Now().Add(-time.Second)
|
|
if err := repo.UpdateGuildPostChecked(charID); err != nil {
|
|
t.Fatalf("UpdateGuildPostChecked failed: %v", err)
|
|
}
|
|
|
|
var got time.Time
|
|
if err := db.QueryRow("SELECT guild_post_checked FROM characters WHERE id=$1", charID).Scan(&got); err != nil {
|
|
t.Fatalf("Verification query failed: %v", err)
|
|
}
|
|
if got.Before(before) {
|
|
t.Errorf("Expected guild_post_checked to be recent, got: %v", got)
|
|
}
|
|
}
|
|
|
|
func TestReadGuildPostChecked(t *testing.T) {
|
|
repo, db, charID := setupCharRepo(t)
|
|
|
|
expected := time.Date(2025, 6, 15, 12, 0, 0, 0, time.UTC)
|
|
if _, err := db.Exec("UPDATE characters SET guild_post_checked=$1 WHERE id=$2", expected, charID); err != nil {
|
|
t.Fatalf("Setup failed: %v", err)
|
|
}
|
|
|
|
got, err := repo.ReadGuildPostChecked(charID)
|
|
if err != nil {
|
|
t.Fatalf("ReadGuildPostChecked failed: %v", err)
|
|
}
|
|
if !got.Equal(expected) {
|
|
t.Errorf("Expected %v, got: %v", expected, got)
|
|
}
|
|
}
|
|
|
|
func TestSaveMercenary(t *testing.T) {
|
|
repo, db, charID := setupCharRepo(t)
|
|
|
|
data := []byte{0x01, 0x02, 0x03, 0x04}
|
|
if err := repo.SaveMercenary(charID, data, 42); err != nil {
|
|
t.Fatalf("SaveMercenary failed: %v", err)
|
|
}
|
|
|
|
var gotData []byte
|
|
var gotRastaID uint32
|
|
if err := db.QueryRow("SELECT savemercenary, rasta_id FROM characters WHERE id=$1", charID).Scan(&gotData, &gotRastaID); err != nil {
|
|
t.Fatalf("Verification query failed: %v", err)
|
|
}
|
|
if len(gotData) != 4 || gotData[0] != 0x01 {
|
|
t.Errorf("Expected mercenary data, got: %x", gotData)
|
|
}
|
|
if gotRastaID != 42 {
|
|
t.Errorf("Expected rasta_id=42, got: %d", gotRastaID)
|
|
}
|
|
}
|
|
|
|
func TestUpdateGCPAndPact(t *testing.T) {
|
|
repo, db, charID := setupCharRepo(t)
|
|
|
|
if err := repo.UpdateGCPAndPact(charID, 100, 55); err != nil {
|
|
t.Fatalf("UpdateGCPAndPact failed: %v", err)
|
|
}
|
|
|
|
var gcp, pactID uint32
|
|
if err := db.QueryRow("SELECT gcp, pact_id FROM characters WHERE id=$1", charID).Scan(&gcp, &pactID); err != nil {
|
|
t.Fatalf("Verification query failed: %v", err)
|
|
}
|
|
if gcp != 100 || pactID != 55 {
|
|
t.Errorf("Expected gcp=100 pact_id=55, got gcp=%d pact_id=%d", gcp, pactID)
|
|
}
|
|
}
|
|
|
|
func TestFindByRastaID(t *testing.T) {
|
|
repo, db, charID := setupCharRepo(t)
|
|
|
|
if _, err := db.Exec("UPDATE characters SET rasta_id=999 WHERE id=$1", charID); err != nil {
|
|
t.Fatalf("Setup failed: %v", err)
|
|
}
|
|
|
|
gotID, gotName, err := repo.FindByRastaID(999)
|
|
if err != nil {
|
|
t.Fatalf("FindByRastaID failed: %v", err)
|
|
}
|
|
if gotID != charID {
|
|
t.Errorf("Expected charID %d, got: %d", charID, gotID)
|
|
}
|
|
if gotName != "RepoChar" {
|
|
t.Errorf("Expected 'RepoChar', got: %q", gotName)
|
|
}
|
|
}
|
|
|
|
func TestLoadSaveData(t *testing.T) {
|
|
repo, _, charID := setupCharRepo(t)
|
|
|
|
id, savedata, isNew, name, err := repo.LoadSaveData(charID)
|
|
if err != nil {
|
|
t.Fatalf("LoadSaveData failed: %v", err)
|
|
}
|
|
if id != charID {
|
|
t.Errorf("Expected charID %d, got: %d", charID, id)
|
|
}
|
|
if name != "RepoChar" {
|
|
t.Errorf("Expected name 'RepoChar', got: %q", name)
|
|
}
|
|
if isNew {
|
|
t.Error("Expected is_new_character=false")
|
|
}
|
|
if savedata == nil {
|
|
t.Error("Expected non-nil savedata")
|
|
}
|
|
}
|
|
|
|
func TestLoadSaveDataNewCharacter(t *testing.T) {
|
|
repo, db, charID := setupCharRepo(t)
|
|
|
|
if _, err := db.Exec("UPDATE characters SET is_new_character=true WHERE id=$1", charID); err != nil {
|
|
t.Fatalf("Setup failed: %v", err)
|
|
}
|
|
|
|
_, _, isNew, _, err := repo.LoadSaveData(charID)
|
|
if err != nil {
|
|
t.Fatalf("LoadSaveData failed: %v", err)
|
|
}
|
|
if !isNew {
|
|
t.Error("Expected is_new_character=true")
|
|
}
|
|
}
|
|
|
|
func TestLoadSaveDataNotFound(t *testing.T) {
|
|
repo, _, _ := setupCharRepo(t)
|
|
|
|
_, _, _, _, err := repo.LoadSaveData(999999)
|
|
if err == nil {
|
|
t.Fatal("Expected error for non-existent character")
|
|
}
|
|
}
|