"""
Game state and persistence tests - validates building placement/removal,
player creation, database save/load operations, and game state integrity
"""
import pytest
import asyncio
import tempfile
import os
from server.game_state import GameState
from server.economy import EconomyEngine
from server.database import Database
from server.models import Player, Building, BuildingType
from tests.test_client import test_clients
class TestGameStateManagement:
"""Test core game state functionality"""
@pytest.fixture
def game_setup(self):
"""Setup fresh game state for testing"""
game_state = GameState()
return game_state
def test_player_creation(self, game_setup):
"""Test player creation and retrieval"""
game_state = game_setup
# Create new player
player = game_state.get_or_create_player("test_user", "test_123")
assert player.nickname == "test_user"
assert player.player_id == "test_123"
assert player.money == 100000 # Starting money
assert player.population == 0
assert player.is_online == True
assert player.color.startswith("#")
# Retrieve existing player
same_player = game_state.get_or_create_player("test_user", "test_123")
assert same_player == player
assert same_player.player_id == "test_123"
def test_building_placement_validation(self, game_setup):
"""Test building placement validation rules"""
game_state = game_setup
player = game_state.get_or_create_player("builder", "builder_123")
# Valid building placement
result = game_state.place_building("builder_123", "small_house", 0, 0)
assert result["success"] == True
assert (0, 0) in game_state.buildings
# Cannot place on occupied tile
result = game_state.place_building("builder_123", "road", 0, 0)
assert result["success"] == False
assert "already occupied" in result["error"]
# Cannot place with insufficient funds
player.money = 100 # Very low money
result = game_state.place_building("builder_123", "power_plant", 1, 1)
assert result["success"] == False
assert "not enough money" in result["error"].lower()
def test_building_removal_validation(self, game_setup):
"""Test building removal validation rules"""
game_state = game_setup
owner = game_state.get_or_create_player("owner", "owner_123")
other = game_state.get_or_create_player("other", "other_123")
# Place building
game_state.place_building("owner_123", "small_house", 5, 5)
# Owner can remove their building
result = game_state.remove_building("owner_123", 5, 5)
assert result["success"] == True
assert (5, 5) not in game_state.buildings
# Place another building
game_state.place_building("owner_123", "small_house", 6, 6)
# Other player cannot remove owner's building
result = game_state.remove_building("other_123", 6, 6)
assert result["success"] == False
assert "don't own" in result["error"].lower()
# Cannot remove non-existent building
result = game_state.remove_building("owner_123", 10, 10)
assert result["success"] == False
assert "no building" in result["error"].lower()
def test_building_edit_validation(self, game_setup):
"""Test building name editing validation"""
game_state = game_setup
owner = game_state.get_or_create_player("owner", "owner_123")
other = game_state.get_or_create_player("other", "other_123")
# Place building
game_state.place_building("owner_123", "small_house", 7, 7)
# Owner can edit their building
result = game_state.edit_building_name("owner_123", 7, 7, "My Home")
assert result["success"] == True
assert game_state.buildings[(7, 7)].name == "My Home"
# Other player cannot edit owner's building
result = game_state.edit_building_name("other_123", 7, 7, "Stolen House")
assert result["success"] == False
assert "don't own" in result["error"].lower()
# Name should remain unchanged
assert game_state.buildings[(7, 7)].name == "My Home"
def test_road_network_connectivity(self, game_setup):
"""Test road network connectivity calculations"""
game_state = game_setup
player = game_state.get_or_create_player("builder", "builder_123")
# Place disconnected roads
game_state.place_building("builder_123", "road", 0, 0)
game_state.place_building("builder_123", "road", 5, 5)
# Should have 2 separate zones
assert len(game_state.connected_zones) == 2
assert {(0, 0)} in game_state.connected_zones
assert {(5, 5)} in game_state.connected_zones
# Connect the roads
game_state.place_building("builder_123", "road", 1, 0)
game_state.place_building("builder_123", "road", 2, 0)
game_state.place_building("builder_123", "road", 3, 0)
game_state.place_building("builder_123", "road", 4, 0)
game_state.place_building("builder_123", "road", 4, 1)
game_state.place_building("builder_123", "road", 4, 2)
game_state.place_building("builder_123", "road", 4, 3)
game_state.place_building("builder_123", "road", 4, 4)
game_state.place_building("builder_123", "road", 4, 5)
game_state.place_building("builder_123", "road", 5, 4)
# Should now be one connected zone
assert len(game_state.connected_zones) == 1
assert len(game_state.connected_zones[0]) == 10 # All roads connected
def test_zone_size_calculation(self, game_setup):
"""Test building zone size calculation for economy bonuses"""
game_state = game_setup
player = game_state.get_or_create_player("builder", "builder_123")
# Place building with no adjacent roads
game_state.place_building("builder_123", "small_shop", 10, 10)
zone_size = game_state.get_building_zone_size(10, 10)
assert zone_size == 0
# Place roads near the building
game_state.place_building("builder_123", "road", 10, 11) # Adjacent
game_state.place_building("builder_123", "road", 10, 12) # Connected
game_state.place_building("builder_123", "road", 11, 12) # Extend network
zone_size = game_state.get_building_zone_size(10, 10)
assert zone_size == 3 # Size of connected road network
def test_power_plant_requirement_checking(self, game_setup):
"""Test power plant requirement validation"""
game_state = game_setup
player = game_state.get_or_create_player("builder", "builder_123")
player.money = 200000 # Enough for expensive buildings
# Cannot place large building without power plant
result = game_state.place_building("builder_123", "large_factory", 0, 0)
assert result["success"] == False
assert "power plant" in result["error"].lower()
# Place power plant first
result = game_state.place_building("builder_123", "power_plant", 5, 5)
assert result["success"] == True
# Now large building should work
result = game_state.place_building("builder_123", "large_factory", 0, 0)
assert result["success"] == True
def test_player_building_retrieval(self, game_setup):
"""Test retrieving all buildings owned by a player"""
game_state = game_setup
player1 = game_state.get_or_create_player("player1", "p1")
player2 = game_state.get_or_create_player("player2", "p2")
# Each player places buildings
game_state.place_building("p1", "small_house", 0, 0)
game_state.place_building("p1", "road", 1, 0)
game_state.place_building("p2", "small_shop", 2, 2)
# Check player buildings
p1_buildings = game_state.get_player_buildings("p1")
p2_buildings = game_state.get_player_buildings("p2")
assert len(p1_buildings) == 2
assert len(p2_buildings) == 1
# Verify building ownership
building_types = [b.building_type.value for b in p1_buildings]
assert "small_house" in building_types
assert "road" in building_types
assert p2_buildings[0].building_type.value == "small_shop"
def test_game_state_serialization(self, game_setup):
"""Test game state serialization for network transmission"""
game_state = game_setup
# Add some players and buildings
player1 = game_state.get_or_create_player("user1", "u1")
player2 = game_state.get_or_create_player("user2", "u2")
game_state.place_building("u1", "small_house", 0, 0)
game_state.place_building("u2", "road", 1, 1)
# Get serialized state
state = game_state.get_state()
# Verify structure
assert "players" in state
assert "buildings" in state
assert len(state["players"]) == 2
assert len(state["buildings"]) == 2
# Verify player data
assert "u1" in state["players"]
assert "u2" in state["players"]
assert state["players"]["u1"]["nickname"] == "user1"
assert state["players"]["u1"]["money"] < 100000 # Money spent on building
# Verify building data
assert "0,0" in state["buildings"]
assert "1,1" in state["buildings"]
assert state["buildings"]["0,0"]["type"] == "small_house"
assert state["buildings"]["0,0"]["owner_id"] == "u1"
class TestDatabasePersistence:
"""Test database save/load functionality"""
@pytest.fixture
def temp_database(self):
"""Create temporary database for testing"""
# Create temporary database file
temp_fd, temp_path = tempfile.mkstemp(suffix=".db")
os.close(temp_fd)
# Create database instance
database = Database()
# Override the default path for testing
database.db_path = temp_path
database.init_db()
yield database
# Cleanup
if os.path.exists(temp_path):
os.unlink(temp_path)
def test_database_initialization(self, temp_database):
"""Test database schema creation"""
db = temp_database
# Database should be initialized without errors
# Tables should exist (this is tested implicitly by other operations)
assert os.path.exists(db.db_path)
def test_save_and_load_game_state(self, temp_database):
"""Test saving and loading complete game state"""
db = temp_database
# Create game state with data
game_state = GameState()
player1 = game_state.get_or_create_player("test_user", "test_123")
player2 = game_state.get_or_create_player("other_user", "other_456")
# Modify player data
player1.money = 75000
player1.population = 50
player2.money = 120000
# Add buildings
game_state.place_building("test_123", "small_house", 5, 5)
game_state.place_building("other_456", "road", 10, 10)
game_state.buildings[(5, 5)].name = "Custom House"
# Save to database
db.save_game_state(game_state)
# Create new game state and load
new_game_state = GameState()
loaded_data = db.load_game_state()
new_game_state.load_state(loaded_data)
# Verify players were loaded correctly
assert len(new_game_state.players) == 2
assert "test_123" in new_game_state.players
assert "other_456" in new_game_state.players
loaded_player1 = new_game_state.players["test_123"]
assert loaded_player1.nickname == "test_user"
assert loaded_player1.money == 75000
assert loaded_player1.population == 50
assert loaded_player1.is_online == False # Players start offline when loaded
# Verify buildings were loaded correctly
assert len(new_game_state.buildings) == 2
assert (5, 5) in new_game_state.buildings
assert (10, 10) in new_game_state.buildings
house = new_game_state.buildings[(5, 5)]
assert house.building_type == BuildingType.SMALL_HOUSE
assert house.owner_id == "test_123"
assert house.name == "Custom House"
road = new_game_state.buildings[(10, 10)]
assert road.building_type == BuildingType.ROAD
assert road.owner_id == "other_456"
def test_empty_database_load(self, temp_database):
"""Test loading from empty database"""
db = temp_database
# Load from empty database
loaded_data = db.load_game_state()
# Should return empty structure
assert loaded_data == {"players": [], "buildings": []}
# Loading into game state should work without errors
game_state = GameState()
game_state.load_state(loaded_data)
assert len(game_state.players) == 0
assert len(game_state.buildings) == 0
def test_database_persistence_across_saves(self, temp_database):
"""Test that database persists data across multiple save operations"""
db = temp_database
game_state = GameState()
# Save initial state
player = game_state.get_or_create_player("persistent_user", "persist_123")
db.save_game_state(game_state)
# Modify and save again
game_state.place_building("persist_123", "small_house", 0, 0)
db.save_game_state(game_state)
# Add more data and save again
game_state.place_building("persist_123", "road", 1, 1)
player.money = 50000
db.save_game_state(game_state)
# Load fresh game state
new_game_state = GameState()
loaded_data = db.load_game_state()
new_game_state.load_state(loaded_data)
# Should have all the data from the last save
assert len(new_game_state.players) == 1
assert len(new_game_state.buildings) == 2
assert new_game_state.players["persist_123"].money == 50000
class TestGameStateIntegration:
"""Integration tests for game state with WebSocket clients"""
@pytest.mark.asyncio
async def test_building_placement_through_websocket(self):
"""Test building placement state changes through WebSocket"""
async with test_clients("state_test") as [client]:
initial_buildings = len(client.game_state["buildings"])
# Place building
await client.place_building("small_house", 3, 3)
# Wait for placement confirmation
message = await client.receive_message(timeout=2.0)
assert message["type"] == "building_placed"
# Verify building data
building = message["building"]
assert building["type"] == "small_house"
assert building["x"] == 3
assert building["y"] == 3
assert building["owner_id"] == client.player_data["player_id"]
@pytest.mark.asyncio
async def test_building_removal_through_websocket(self):
"""Test building removal state changes through WebSocket"""
async with test_clients("remove_test") as [client]:
# Place building first
await client.place_building("small_house", 8, 8)
placement_msg = await client.receive_message(timeout=2.0)
assert placement_msg["type"] == "building_placed"
# Remove building
await client.remove_building(8, 8)
# Wait for removal confirmation
message = await client.receive_message(timeout=2.0)
assert message["type"] == "building_removed"
assert message["x"] == 8
assert message["y"] == 8
@pytest.mark.asyncio
async def test_player_state_persistence(self):
"""Test that player state persists across connections"""
# First connection - place building and spend money
async with test_clients("persistence_test") as [client1]:
initial_money = client1.get_money()
await client1.place_building("small_house", 15, 15)
# Wait for the building to be placed and economy update
await asyncio.sleep(1.5)
# Reconnect with same nickname
async with test_clients("persistence_test") as [client2]:
# Money should be reduced by building cost
assert client2.get_money() < initial_money
expected_money = initial_money - 5000 # Small house cost
# Allow for economy ticks that might have occurred
money_difference = abs(client2.get_money() - expected_money)
assert money_difference <= 100 # Allow for small economy changes
@pytest.mark.asyncio
async def test_invalid_building_placement_error_handling(self):
"""Test error handling for invalid building placements"""
async with test_clients("error_test") as [client]:
# Place building on valid location
await client.place_building("small_house", 0, 0)
await client.receive_message(timeout=2.0) # Wait for placement
# Try to place another building on same location
await client.place_building("road", 0, 0)
# Should receive error message
message = await client.receive_message(timeout=2.0)
assert message["type"] == "error"
assert "occupied" in message["message"].lower()
@pytest.mark.asyncio
async def test_building_name_editing(self):
"""Test building name editing through WebSocket"""
async with test_clients("editor") as [client]:
# Place building
await client.place_building("small_house", 12, 12)
await client.receive_message(timeout=2.0) # Wait for placement
# Edit building name
new_name = "My Custom House"
await client.edit_building(12, 12, new_name)
# Should receive update confirmation
message = await client.receive_message(timeout=2.0)
assert message["type"] == "building_updated"
assert message["x"] == 12
assert message["y"] == 12
assert message["name"] == new_name
Reference in New Issue View Git Blame Copy Permalink