294 lines
6.9 KiB
Go
294 lines
6.9 KiB
Go
package player
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
|
|
"eq2emu/internal/database"
|
|
)
|
|
|
|
// MockLogger for testing
|
|
type MockLogger struct{}
|
|
|
|
func (ml *MockLogger) Debug(format string, args ...interface{}) {}
|
|
func (ml *MockLogger) Info(format string, args ...interface{}) {}
|
|
func (ml *MockLogger) Warn(format string, args ...interface{}) {}
|
|
func (ml *MockLogger) Error(format string, args ...interface{}) {}
|
|
|
|
// MockConfig for testing
|
|
type MockConfig struct{}
|
|
|
|
func (mc *MockConfig) GetString(key string) string { return "" }
|
|
func (mc *MockConfig) GetInt(key string) int { return 0 }
|
|
func (mc *MockConfig) GetBool(key string) bool { return false }
|
|
|
|
func TestPlayerManagerCreation(t *testing.T) {
|
|
logger := &MockLogger{}
|
|
config := &MockConfig{}
|
|
var db *database.Database // Use nil for testing
|
|
|
|
manager := NewPlayerManager(db, logger, config)
|
|
if manager == nil {
|
|
t.Fatal("Failed to create PlayerManager")
|
|
}
|
|
|
|
// Test that manager starts empty
|
|
players := manager.GetAllPlayers()
|
|
if len(players) != 0 {
|
|
t.Errorf("Expected 0 players, got %d", len(players))
|
|
}
|
|
}
|
|
|
|
func TestPlayerManagerAddRemove(t *testing.T) {
|
|
logger := &MockLogger{}
|
|
config := &MockConfig{}
|
|
var db *database.Database
|
|
|
|
manager := NewPlayerManager(db, logger, config)
|
|
|
|
// Create a test player
|
|
player := NewPlayer()
|
|
player.charID = 12345
|
|
player.SetLevel(10)
|
|
|
|
// Test adding player
|
|
manager.AddPlayer(player)
|
|
|
|
// Verify player was added
|
|
retrievedPlayer := manager.GetPlayer(12345)
|
|
if retrievedPlayer == nil {
|
|
t.Error("Failed to retrieve added player")
|
|
}
|
|
|
|
if retrievedPlayer.GetCharacterID() != 12345 {
|
|
t.Errorf("Expected character ID 12345, got %d", retrievedPlayer.GetCharacterID())
|
|
}
|
|
|
|
// Test getting all players
|
|
allPlayers := manager.GetAllPlayers()
|
|
if len(allPlayers) != 1 {
|
|
t.Errorf("Expected 1 player, got %d", len(allPlayers))
|
|
}
|
|
|
|
// Test removing player
|
|
manager.RemovePlayer(12345)
|
|
|
|
removedPlayer := manager.GetPlayer(12345)
|
|
if removedPlayer != nil {
|
|
t.Error("Player should have been removed")
|
|
}
|
|
}
|
|
|
|
func TestPlayerManagerMultiplePlayers(t *testing.T) {
|
|
logger := &MockLogger{}
|
|
config := &MockConfig{}
|
|
var db *database.Database
|
|
|
|
manager := NewPlayerManager(db, logger, config)
|
|
|
|
// Add multiple players
|
|
for i := 1; i <= 5; i++ {
|
|
player := NewPlayer()
|
|
player.charID = int32(i)
|
|
player.SetLevel(int16(10 * i))
|
|
manager.AddPlayer(player)
|
|
}
|
|
|
|
// Verify all players were added
|
|
allPlayers := manager.GetAllPlayers()
|
|
if len(allPlayers) != 5 {
|
|
t.Errorf("Expected 5 players, got %d", len(allPlayers))
|
|
}
|
|
|
|
// Test retrieving specific players
|
|
for i := 1; i <= 5; i++ {
|
|
player := manager.GetPlayer(int32(i))
|
|
if player == nil {
|
|
t.Errorf("Failed to retrieve player %d", i)
|
|
}
|
|
if player.GetLevel() != int8(10*i) {
|
|
t.Errorf("Expected level %d, got %d", 10*i, player.GetLevel())
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestPlayerManagerExperience(t *testing.T) {
|
|
logger := &MockLogger{}
|
|
config := &MockConfig{}
|
|
var db *database.Database
|
|
|
|
manager := NewPlayerManager(db, logger, config)
|
|
|
|
// Create and add a test player
|
|
player := NewPlayer()
|
|
player.charID = 999
|
|
player.SetLevel(5)
|
|
manager.AddPlayer(player)
|
|
|
|
// Test adding experience (should not error even though it's simplified)
|
|
err := manager.AddExperience(999, 1000, "adventure")
|
|
if err != nil {
|
|
t.Errorf("AddExperience failed: %v", err)
|
|
}
|
|
|
|
// Test adding tradeskill experience
|
|
err = manager.AddExperience(999, 500, "tradeskill")
|
|
if err != nil {
|
|
t.Errorf("AddExperience tradeskill failed: %v", err)
|
|
}
|
|
|
|
// Test invalid XP type
|
|
err = manager.AddExperience(999, 100, "invalid")
|
|
if err == nil {
|
|
t.Error("Expected error for invalid XP type")
|
|
}
|
|
|
|
// Test non-existent player
|
|
err = manager.AddExperience(888, 100, "adventure")
|
|
if err == nil {
|
|
t.Error("Expected error for non-existent player")
|
|
}
|
|
}
|
|
|
|
func TestPlayerManagerCombat(t *testing.T) {
|
|
logger := &MockLogger{}
|
|
config := &MockConfig{}
|
|
var db *database.Database
|
|
|
|
manager := NewPlayerManager(db, logger, config)
|
|
|
|
// Create test players
|
|
attacker := NewPlayer()
|
|
attacker.charID = 100
|
|
manager.AddPlayer(attacker)
|
|
|
|
defender := NewPlayer()
|
|
defender.charID = 200
|
|
manager.AddPlayer(defender)
|
|
|
|
// Test combat processing
|
|
err := manager.ProcessCombat(100, 200, 50)
|
|
if err != nil {
|
|
t.Errorf("ProcessCombat failed: %v", err)
|
|
}
|
|
|
|
// Test combat with non-existent attacker
|
|
err = manager.ProcessCombat(999, 200, 30)
|
|
if err == nil {
|
|
t.Error("Expected error for non-existent attacker")
|
|
}
|
|
}
|
|
|
|
func TestPlayerManagerCurrency(t *testing.T) {
|
|
logger := &MockLogger{}
|
|
config := &MockConfig{}
|
|
var db *database.Database
|
|
|
|
manager := NewPlayerManager(db, logger, config)
|
|
|
|
// Create test player
|
|
player := NewPlayer()
|
|
player.charID = 300
|
|
manager.AddPlayer(player)
|
|
|
|
// Test currency updates
|
|
err := manager.UpdateCurrency(300, "coin", 1000)
|
|
if err != nil {
|
|
t.Errorf("UpdateCurrency coin failed: %v", err)
|
|
}
|
|
|
|
err = manager.UpdateCurrency(300, "tokens", 50)
|
|
if err != nil {
|
|
t.Errorf("UpdateCurrency tokens failed: %v", err)
|
|
}
|
|
|
|
err = manager.UpdateCurrency(300, "status", 25)
|
|
if err != nil {
|
|
t.Errorf("UpdateCurrency status failed: %v", err)
|
|
}
|
|
|
|
// Test invalid currency type
|
|
err = manager.UpdateCurrency(300, "invalid", 100)
|
|
if err == nil {
|
|
t.Error("Expected error for invalid currency type")
|
|
}
|
|
}
|
|
|
|
func TestPlayerManagerLevelUp(t *testing.T) {
|
|
logger := &MockLogger{}
|
|
config := &MockConfig{}
|
|
var db *database.Database
|
|
|
|
manager := NewPlayerManager(db, logger, config)
|
|
|
|
// Create test player
|
|
player := NewPlayer()
|
|
player.charID = 400
|
|
player.SetLevel(10)
|
|
manager.AddPlayer(player)
|
|
|
|
// Test level up
|
|
err := manager.UpdatePlayerLevel(400, 11)
|
|
if err != nil {
|
|
t.Errorf("UpdatePlayerLevel failed: %v", err)
|
|
}
|
|
|
|
// Verify level was updated
|
|
updatedPlayer := manager.GetPlayer(400)
|
|
if updatedPlayer.GetLevel() != 11 {
|
|
t.Errorf("Expected level 11, got %d", updatedPlayer.GetLevel())
|
|
}
|
|
|
|
// Test level up for non-existent player
|
|
err = manager.UpdatePlayerLevel(999, 20)
|
|
if err == nil {
|
|
t.Error("Expected error for non-existent player")
|
|
}
|
|
}
|
|
|
|
func TestPlayerManagerSave(t *testing.T) {
|
|
logger := &MockLogger{}
|
|
config := &MockConfig{}
|
|
var db *database.Database
|
|
|
|
manager := NewPlayerManager(db, logger, config)
|
|
|
|
// Create test player
|
|
player := NewPlayer()
|
|
player.charID = 500
|
|
manager.AddPlayer(player)
|
|
|
|
// Test save player (should not panic even with nil database)
|
|
err := manager.SavePlayer(500)
|
|
if err != nil {
|
|
// Expected since we're using nil database
|
|
t.Logf("Save failed as expected with nil database: %v", err)
|
|
}
|
|
|
|
// Test save all players
|
|
err = manager.SaveAllPlayers()
|
|
if err != nil {
|
|
t.Errorf("SaveAllPlayers failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestPlayerManagerShutdown(t *testing.T) {
|
|
logger := &MockLogger{}
|
|
config := &MockConfig{}
|
|
var db *database.Database
|
|
|
|
manager := NewPlayerManager(db, logger, config)
|
|
|
|
// Add some test players
|
|
for i := 1; i <= 3; i++ {
|
|
player := NewPlayer()
|
|
player.charID = int32(600 + i)
|
|
manager.AddPlayer(player)
|
|
}
|
|
|
|
// Test graceful shutdown (should not panic)
|
|
manager.Shutdown()
|
|
|
|
// Give a moment for background processes to stop
|
|
time.Sleep(100 * time.Millisecond)
|
|
} |