CLAUDE: Enhance WebSocket handlers with comprehensive test coverage
WebSocket Infrastructure: - Connection manager: Improved connection/disconnection handling - Handlers: Enhanced event handlers for game operations Test Coverage (148 new tests): - test_connection_handlers.py: Connection lifecycle tests - test_connection_manager.py: Manager operations tests - test_handler_locking.py: Concurrency/locking tests - test_query_handlers.py: Game query handler tests - test_rate_limiting.py: Rate limit enforcement tests - test_substitution_handlers.py: Player substitution tests - test_manual_outcome_handlers.py: Manual outcome workflow tests - conftest.py: Shared WebSocket test fixtures 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Cal Corum
parent
3623ad6978
commit
4253b71db9
@ -1,71 +1,288 @@
|
||||
import logging
|
||||
"""
|
||||
WebSocket Connection Manager
|
||||
|
||||
Manages WebSocket connections, session tracking, and room broadcasting.
|
||||
Includes session expiration for cleaning up zombie connections.
|
||||
"""
|
||||
|
||||
import logging
|
||||
from dataclasses import dataclass, field
|
||||
from uuid import UUID
|
||||
|
||||
import pendulum
|
||||
import socketio
|
||||
from pendulum import DateTime
|
||||
|
||||
from app.config import get_settings
|
||||
|
||||
logger = logging.getLogger(f"{__name__}.ConnectionManager")
|
||||
|
||||
|
||||
@dataclass
|
||||
class SessionInfo:
|
||||
"""
|
||||
Tracks metadata for a WebSocket session.
|
||||
|
||||
Used for:
|
||||
- Identifying session owner (user_id)
|
||||
- Tracking session lifetime (connected_at)
|
||||
- Detecting zombie connections (last_activity)
|
||||
- Managing game room membership (games)
|
||||
"""
|
||||
|
||||
user_id: str | None
|
||||
connected_at: DateTime
|
||||
last_activity: DateTime
|
||||
games: set[str] = field(default_factory=set)
|
||||
ip_address: str | None = None
|
||||
|
||||
def inactive_seconds(self) -> float:
|
||||
"""Return seconds since last activity."""
|
||||
return (pendulum.now("UTC") - self.last_activity).total_seconds()
|
||||
|
||||
|
||||
class ConnectionManager:
|
||||
"""Manages WebSocket connections and rooms"""
|
||||
"""
|
||||
Manages WebSocket connections and rooms.
|
||||
|
||||
Features:
|
||||
- Session lifecycle management (connect/disconnect)
|
||||
- Activity tracking for zombie detection
|
||||
- Game room management (join/leave/broadcast)
|
||||
- Session expiration for cleanup
|
||||
- Connection statistics for health monitoring
|
||||
"""
|
||||
|
||||
def __init__(self, sio: socketio.AsyncServer):
|
||||
self.sio = sio
|
||||
self.user_sessions: dict[str, str] = {} # sid -> user_id
|
||||
self._sessions: dict[str, SessionInfo] = {} # sid -> SessionInfo
|
||||
self._user_sessions: dict[str, set[str]] = {} # user_id -> set of sids
|
||||
self.game_rooms: dict[str, set[str]] = {} # game_id -> set of sids
|
||||
|
||||
async def connect(self, sid: str, user_id: str) -> None:
|
||||
"""Register a new connection"""
|
||||
self.user_sessions[sid] = user_id
|
||||
logger.info(f"User {user_id} connected with session {sid}")
|
||||
@property
|
||||
def user_sessions(self) -> dict[str, str | None]:
|
||||
"""
|
||||
Backward-compatible property: returns sid -> user_id mapping.
|
||||
|
||||
Used by existing tests and code that expects simple session tracking.
|
||||
"""
|
||||
return {sid: info.user_id for sid, info in self._sessions.items()}
|
||||
|
||||
async def connect(
|
||||
self, sid: str, user_id: str, ip_address: str | None = None
|
||||
) -> None:
|
||||
"""
|
||||
Register a new connection with session tracking.
|
||||
|
||||
Args:
|
||||
sid: Socket.io session ID
|
||||
user_id: Authenticated user ID
|
||||
ip_address: Client IP address (optional, for logging)
|
||||
"""
|
||||
now = pendulum.now("UTC")
|
||||
self._sessions[sid] = SessionInfo(
|
||||
user_id=user_id,
|
||||
connected_at=now,
|
||||
last_activity=now,
|
||||
games=set(),
|
||||
ip_address=ip_address,
|
||||
)
|
||||
|
||||
# Track user's multiple sessions (e.g., multiple browser tabs)
|
||||
if user_id not in self._user_sessions:
|
||||
self._user_sessions[user_id] = set()
|
||||
self._user_sessions[user_id].add(sid)
|
||||
|
||||
logger.info(f"User {user_id} connected with session {sid} from {ip_address}")
|
||||
|
||||
async def disconnect(self, sid: str) -> None:
|
||||
"""Handle disconnection"""
|
||||
user_id = self.user_sessions.pop(sid, None)
|
||||
if user_id:
|
||||
logger.info(f"User {user_id} disconnected (session {sid})")
|
||||
"""
|
||||
Handle disconnection and cleanup session.
|
||||
|
||||
Removes session from all tracking structures and game rooms.
|
||||
"""
|
||||
session = self._sessions.pop(sid, None)
|
||||
if session:
|
||||
# Remove from user tracking
|
||||
if session.user_id and session.user_id in self._user_sessions:
|
||||
self._user_sessions[session.user_id].discard(sid)
|
||||
if not self._user_sessions[session.user_id]:
|
||||
del self._user_sessions[session.user_id]
|
||||
|
||||
# Remove from all game rooms
|
||||
for game_id, sids in self.game_rooms.items():
|
||||
if sid in sids:
|
||||
sids.remove(sid)
|
||||
for game_id in list(session.games):
|
||||
if game_id in self.game_rooms:
|
||||
self.game_rooms[game_id].discard(sid)
|
||||
await self.broadcast_to_game(
|
||||
game_id, "user_disconnected", {"user_id": user_id}
|
||||
game_id, "user_disconnected", {"user_id": session.user_id}
|
||||
)
|
||||
|
||||
duration = (pendulum.now("UTC") - session.connected_at).total_seconds()
|
||||
logger.info(
|
||||
f"User {session.user_id} disconnected (session {sid}, "
|
||||
f"duration: {duration:.0f}s)"
|
||||
)
|
||||
else:
|
||||
logger.debug(f"Unknown session {sid} disconnected")
|
||||
|
||||
async def update_activity(self, sid: str) -> None:
|
||||
"""
|
||||
Update last activity timestamp for session.
|
||||
|
||||
Call this on any meaningful user action to prevent
|
||||
the session from being marked as zombie.
|
||||
"""
|
||||
if sid in self._sessions:
|
||||
self._sessions[sid].last_activity = pendulum.now("UTC")
|
||||
|
||||
def get_session(self, sid: str) -> SessionInfo | None:
|
||||
"""Get session info for a connection."""
|
||||
return self._sessions.get(sid)
|
||||
|
||||
def get_user_id(self, sid: str) -> str | None:
|
||||
"""Get user ID for a session (convenience method)."""
|
||||
session = self._sessions.get(sid)
|
||||
return session.user_id if session else None
|
||||
|
||||
async def join_game(self, sid: str, game_id: str, role: str) -> None:
|
||||
"""Add user to game room"""
|
||||
"""
|
||||
Add user to game room.
|
||||
|
||||
Args:
|
||||
sid: Socket.io session ID
|
||||
game_id: Game UUID as string
|
||||
role: User role in game (player, spectator)
|
||||
"""
|
||||
await self.sio.enter_room(sid, game_id)
|
||||
|
||||
if game_id not in self.game_rooms:
|
||||
self.game_rooms[game_id] = set()
|
||||
self.game_rooms[game_id].add(sid)
|
||||
|
||||
user_id = self.user_sessions.get(sid)
|
||||
# Update session's game tracking
|
||||
if sid in self._sessions:
|
||||
self._sessions[sid].games.add(game_id)
|
||||
|
||||
user_id = self.get_user_id(sid)
|
||||
logger.info(f"User {user_id} joined game {game_id} as {role}")
|
||||
|
||||
await self.broadcast_to_game(
|
||||
game_id, "user_connected", {"user_id": user_id, "role": role}
|
||||
)
|
||||
|
||||
# Update activity
|
||||
await self.update_activity(sid)
|
||||
|
||||
async def leave_game(self, sid: str, game_id: str) -> None:
|
||||
"""Remove user from game room"""
|
||||
"""Remove user from game room."""
|
||||
await self.sio.leave_room(sid, game_id)
|
||||
|
||||
if game_id in self.game_rooms:
|
||||
self.game_rooms[game_id].discard(sid)
|
||||
|
||||
user_id = self.user_sessions.get(sid)
|
||||
# Update session's game tracking
|
||||
if sid in self._sessions:
|
||||
self._sessions[sid].games.discard(game_id)
|
||||
|
||||
user_id = self.get_user_id(sid)
|
||||
logger.info(f"User {user_id} left game {game_id}")
|
||||
|
||||
async def broadcast_to_game(self, game_id: str, event: str, data: dict) -> None:
|
||||
"""Broadcast event to all users in game room"""
|
||||
"""Broadcast event to all users in game room."""
|
||||
await self.sio.emit(event, data, room=game_id)
|
||||
logger.debug(f"Broadcast {event} to game {game_id}")
|
||||
|
||||
async def emit_to_user(self, sid: str, event: str, data: dict) -> None:
|
||||
"""Emit event to specific user"""
|
||||
"""Emit event to specific user."""
|
||||
await self.sio.emit(event, data, room=sid)
|
||||
|
||||
def get_game_participants(self, game_id: str) -> set[str]:
|
||||
"""Get all session IDs in game room"""
|
||||
"""Get all session IDs in game room."""
|
||||
return self.game_rooms.get(game_id, set())
|
||||
|
||||
async def expire_inactive_sessions(self, timeout_seconds: int | None = None) -> list[str]:
|
||||
"""
|
||||
Expire sessions with no activity beyond timeout.
|
||||
|
||||
This is called periodically by a background task to clean up
|
||||
zombie connections that weren't properly disconnected.
|
||||
|
||||
Args:
|
||||
timeout_seconds: Override default timeout (uses config if None)
|
||||
|
||||
Returns:
|
||||
List of expired session IDs
|
||||
"""
|
||||
if timeout_seconds is None:
|
||||
settings = get_settings()
|
||||
# Use connection timeout as inactivity threshold (default 60s)
|
||||
# This is separate from Socket.io's ping_timeout which handles transport-level issues
|
||||
# This handles application-level inactivity (no events for extended period)
|
||||
timeout_seconds = settings.ws_connection_timeout * 5 # 5 min default
|
||||
|
||||
expired = []
|
||||
|
||||
for sid, session in list(self._sessions.items()):
|
||||
inactive_secs = session.inactive_seconds()
|
||||
if inactive_secs > timeout_seconds:
|
||||
expired.append(sid)
|
||||
logger.warning(
|
||||
f"Expiring inactive session {sid} (user={session.user_id}, "
|
||||
f"inactive {inactive_secs:.0f}s)"
|
||||
)
|
||||
|
||||
for sid in expired:
|
||||
await self.disconnect(sid)
|
||||
# Force Socket.io to close the connection
|
||||
try:
|
||||
await self.sio.disconnect(sid)
|
||||
except Exception as e:
|
||||
logger.debug(f"Error disconnecting expired session {sid}: {e}")
|
||||
|
||||
if expired:
|
||||
logger.info(f"Expired {len(expired)} inactive sessions")
|
||||
|
||||
return expired
|
||||
|
||||
def get_stats(self) -> dict:
|
||||
"""
|
||||
Return connection statistics for health monitoring.
|
||||
|
||||
Includes:
|
||||
- Total active sessions
|
||||
- Unique connected users
|
||||
- Active game rooms
|
||||
- Per-game participant counts
|
||||
- Session age statistics
|
||||
"""
|
||||
now = pendulum.now("UTC")
|
||||
|
||||
# Calculate session age stats
|
||||
session_ages = []
|
||||
inactive_counts = {"<1m": 0, "1-5m": 0, "5-15m": 0, ">15m": 0}
|
||||
|
||||
for session in self._sessions.values():
|
||||
age = (now - session.connected_at).total_seconds()
|
||||
session_ages.append(age)
|
||||
|
||||
inactive = session.inactive_seconds()
|
||||
if inactive < 60:
|
||||
inactive_counts["<1m"] += 1
|
||||
elif inactive < 300:
|
||||
inactive_counts["1-5m"] += 1
|
||||
elif inactive < 900:
|
||||
inactive_counts["5-15m"] += 1
|
||||
else:
|
||||
inactive_counts[">15m"] += 1
|
||||
|
||||
return {
|
||||
"total_sessions": len(self._sessions),
|
||||
"unique_users": len(self._user_sessions),
|
||||
"active_game_rooms": len([r for r in self.game_rooms.values() if r]),
|
||||
"sessions_per_game": {
|
||||
gid: len(sids) for gid, sids in self.game_rooms.items() if sids
|
||||
},
|
||||
"oldest_session_seconds": max(session_ages) if session_ages else 0,
|
||||
"avg_session_seconds": sum(session_ages) / len(session_ages) if session_ages else 0,
|
||||
"inactivity_distribution": inactive_counts,
|
||||
}
|
||||
|
||||
@ -542,14 +542,23 @@ def register_handlers(sio: AsyncServer, manager: ConnectionManager) -> None:
|
||||
play_result_data = {
|
||||
"game_id": str(game_id),
|
||||
"play_number": state.play_count,
|
||||
"inning": state.inning,
|
||||
"half": state.half,
|
||||
"outcome": result.outcome.value, # Use resolved outcome, not submitted
|
||||
"hit_location": submission.hit_location,
|
||||
"description": result.description,
|
||||
"outs_recorded": result.outs_recorded,
|
||||
"runs_scored": result.runs_scored,
|
||||
"batter_result": result.batter_result,
|
||||
"batter_lineup_id": state.current_batter.lineup_id if state.current_batter else None,
|
||||
"runners_advanced": [
|
||||
{"from": adv[0], "to": adv[1]} for adv in result.runners_advanced
|
||||
{
|
||||
"from": adv.from_base,
|
||||
"to": adv.to_base,
|
||||
"lineup_id": adv.lineup_id,
|
||||
"is_out": adv.is_out,
|
||||
}
|
||||
for adv in result.runners_advanced
|
||||
],
|
||||
"is_hit": result.is_hit,
|
||||
"is_out": result.is_out,
|
||||
|
||||
445
backend/tests/unit/websocket/conftest.py
Normal file
445
backend/tests/unit/websocket/conftest.py
Normal file
@ -0,0 +1,445 @@
|
||||
"""
|
||||
Shared fixtures for WebSocket handler tests.
|
||||
|
||||
Provides reusable mock objects and test utilities for all WebSocket test files.
|
||||
Follows the pattern established in test_manual_outcome_handlers.py.
|
||||
|
||||
Author: Claude
|
||||
Date: 2025-01-27
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import pytest
|
||||
from contextlib import asynccontextmanager
|
||||
from uuid import uuid4
|
||||
from unittest.mock import AsyncMock, MagicMock, patch
|
||||
|
||||
import pendulum
|
||||
|
||||
from app.models.game_models import (
|
||||
GameState,
|
||||
LineupPlayerState,
|
||||
TeamLineupState,
|
||||
ManualOutcomeSubmission,
|
||||
)
|
||||
from app.config.result_charts import PlayOutcome
|
||||
from app.core.roll_types import AbRoll, RollType
|
||||
from app.core.play_resolver import PlayResult
|
||||
from app.core.substitution_manager import SubstitutionResult
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# CONNECTION MANAGER FIXTURES
|
||||
# ============================================================================
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_manager():
|
||||
"""
|
||||
Mock ConnectionManager with AsyncMock methods for event emission.
|
||||
|
||||
Tracks calls to emit_to_user and broadcast_to_game for assertion.
|
||||
"""
|
||||
manager = MagicMock()
|
||||
manager.emit_to_user = AsyncMock()
|
||||
manager.broadcast_to_game = AsyncMock()
|
||||
manager.join_game = AsyncMock()
|
||||
manager.leave_game = AsyncMock()
|
||||
manager.connect = AsyncMock()
|
||||
manager.disconnect = AsyncMock()
|
||||
manager.update_activity = AsyncMock() # Session activity tracking
|
||||
# Tracking dictionaries
|
||||
manager.user_sessions = {}
|
||||
manager.game_rooms = {}
|
||||
return manager
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# STATE MANAGER FIXTURES
|
||||
# ============================================================================
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_state_manager():
|
||||
"""
|
||||
Mock state_manager singleton with game_lock context manager.
|
||||
|
||||
Provides:
|
||||
- get_state() returning mock game state
|
||||
- update_state() tracking calls
|
||||
- game_lock() as async context manager
|
||||
- get_lineup() returning mock lineup
|
||||
- recover_game() for state recovery
|
||||
"""
|
||||
state_mgr = MagicMock()
|
||||
state_mgr.get_state = MagicMock(return_value=None)
|
||||
state_mgr.update_state = MagicMock()
|
||||
state_mgr.get_lineup = MagicMock(return_value=None)
|
||||
state_mgr.set_lineup = MagicMock()
|
||||
state_mgr.recover_game = AsyncMock(return_value=None)
|
||||
|
||||
# Create a proper async context manager for game_lock
|
||||
@asynccontextmanager
|
||||
async def mock_game_lock(game_id, timeout=30.0):
|
||||
yield
|
||||
|
||||
state_mgr.game_lock = mock_game_lock
|
||||
return state_mgr
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_state_manager_with_timeout():
|
||||
"""
|
||||
Mock state_manager that raises TimeoutError on game_lock.
|
||||
|
||||
Use this to test timeout handling in handlers.
|
||||
"""
|
||||
state_mgr = MagicMock()
|
||||
state_mgr.get_state = MagicMock(return_value=None)
|
||||
state_mgr.update_state = MagicMock()
|
||||
|
||||
@asynccontextmanager
|
||||
async def timeout_lock(game_id, timeout=30.0):
|
||||
raise asyncio.TimeoutError(f"Lock timeout for game {game_id}")
|
||||
yield # Never reached, but needed for syntax
|
||||
|
||||
state_mgr.game_lock = timeout_lock
|
||||
return state_mgr
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# GAME ENGINE FIXTURES
|
||||
# ============================================================================
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_game_engine():
|
||||
"""
|
||||
Mock game_engine singleton.
|
||||
|
||||
Provides:
|
||||
- resolve_manual_play() for outcome resolution
|
||||
- submit_defensive_decision() for defense strategy
|
||||
- submit_offensive_decision() for offense strategy
|
||||
"""
|
||||
engine = MagicMock()
|
||||
engine.resolve_manual_play = AsyncMock(return_value=None)
|
||||
engine.submit_defensive_decision = AsyncMock(return_value=None)
|
||||
engine.submit_offensive_decision = AsyncMock(return_value=None)
|
||||
engine.start_game = AsyncMock(return_value=None)
|
||||
return engine
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# DICE SYSTEM FIXTURES
|
||||
# ============================================================================
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_dice_system(mock_ab_roll):
|
||||
"""
|
||||
Mock dice_system singleton.
|
||||
|
||||
Returns mock_ab_roll from roll_ab().
|
||||
"""
|
||||
dice = MagicMock()
|
||||
dice.roll_ab = MagicMock(return_value=mock_ab_roll)
|
||||
return dice
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# GAME STATE FIXTURES
|
||||
# ============================================================================
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def sample_game_id():
|
||||
"""Generate a unique game ID for each test."""
|
||||
return uuid4()
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_game_state(sample_game_id):
|
||||
"""
|
||||
Create a mock active game state with current batter set.
|
||||
|
||||
Returns a GameState configured for:
|
||||
- SBA league
|
||||
- Active status
|
||||
- Inning 1, top half
|
||||
- 0 outs, 0-0 score
|
||||
- Current batter assigned
|
||||
"""
|
||||
return GameState(
|
||||
game_id=sample_game_id,
|
||||
league_id="sba",
|
||||
home_team_id=1,
|
||||
away_team_id=2,
|
||||
current_batter=LineupPlayerState(
|
||||
lineup_id=1,
|
||||
card_id=100,
|
||||
position="CF",
|
||||
batting_order=1,
|
||||
),
|
||||
status="active",
|
||||
inning=1,
|
||||
half="top",
|
||||
outs=0,
|
||||
home_score=0,
|
||||
away_score=0,
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_game_state_with_runners(mock_game_state):
|
||||
"""
|
||||
Create game state with runners on base.
|
||||
|
||||
Runner on first and third (corners situation).
|
||||
"""
|
||||
mock_game_state.runner_on_first = LineupPlayerState(
|
||||
lineup_id=2, card_id=200, position="LF", batting_order=2
|
||||
)
|
||||
mock_game_state.runner_on_third = LineupPlayerState(
|
||||
lineup_id=3, card_id=300, position="RF", batting_order=3
|
||||
)
|
||||
return mock_game_state
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# ROLL FIXTURES
|
||||
# ============================================================================
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_ab_roll(sample_game_id):
|
||||
"""
|
||||
Create a mock AB roll for dice operations.
|
||||
|
||||
Standard roll values for predictable test behavior.
|
||||
"""
|
||||
return AbRoll(
|
||||
roll_id="test_roll_123",
|
||||
roll_type=RollType.AB,
|
||||
league_id="sba",
|
||||
timestamp=pendulum.now("UTC"),
|
||||
game_id=sample_game_id,
|
||||
d6_one=3,
|
||||
d6_two_a=4,
|
||||
d6_two_b=3,
|
||||
chaos_d20=10,
|
||||
resolution_d20=12,
|
||||
d6_two_total=7,
|
||||
check_wild_pitch=False,
|
||||
check_passed_ball=False,
|
||||
)
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# PLAY RESULT FIXTURES
|
||||
# ============================================================================
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_play_result():
|
||||
"""
|
||||
Create a mock play result for outcome resolution.
|
||||
|
||||
Standard groundball out result.
|
||||
"""
|
||||
return PlayResult(
|
||||
outcome=PlayOutcome.GROUNDBALL_C,
|
||||
outs_recorded=1,
|
||||
runs_scored=0,
|
||||
batter_result=None,
|
||||
runners_advanced=[],
|
||||
description="Groundball to shortstop",
|
||||
ab_roll=None,
|
||||
is_hit=False,
|
||||
is_out=True,
|
||||
is_walk=False,
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_play_result_hit():
|
||||
"""Create a mock play result for a hit."""
|
||||
return PlayResult(
|
||||
outcome=PlayOutcome.SINGLE,
|
||||
outs_recorded=0,
|
||||
runs_scored=0,
|
||||
batter_result="1B",
|
||||
runners_advanced=[("B", "1B")],
|
||||
description="Single to left field",
|
||||
ab_roll=None,
|
||||
is_hit=True,
|
||||
is_out=False,
|
||||
is_walk=False,
|
||||
)
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# SUBSTITUTION FIXTURES
|
||||
# ============================================================================
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_substitution_result_success():
|
||||
"""Create a successful substitution result."""
|
||||
return SubstitutionResult(
|
||||
success=True,
|
||||
player_out_lineup_id=1,
|
||||
player_in_card_id=999,
|
||||
new_lineup_id=100,
|
||||
new_position="CF",
|
||||
new_batting_order=1,
|
||||
error_message=None,
|
||||
error_code=None,
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_substitution_result_failure():
|
||||
"""Create a failed substitution result."""
|
||||
return SubstitutionResult(
|
||||
success=False,
|
||||
player_out_lineup_id=1,
|
||||
player_in_card_id=999,
|
||||
new_lineup_id=None,
|
||||
new_position=None,
|
||||
new_batting_order=None,
|
||||
error_message="Player not found in roster",
|
||||
error_code="PLAYER_NOT_IN_ROSTER",
|
||||
)
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# LINEUP FIXTURES
|
||||
# ============================================================================
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_lineup_state():
|
||||
"""
|
||||
Create a mock team lineup state.
|
||||
|
||||
9 players in standard batting order with positions.
|
||||
"""
|
||||
players = []
|
||||
positions = ["C", "1B", "2B", "SS", "3B", "LF", "CF", "RF", "DH"]
|
||||
for i in range(9):
|
||||
players.append(
|
||||
LineupPlayerState(
|
||||
lineup_id=i + 1,
|
||||
card_id=(i + 1) * 100,
|
||||
position=positions[i],
|
||||
batting_order=i + 1,
|
||||
)
|
||||
)
|
||||
return TeamLineupState(team_id=1, players=players)
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# SOCKET.IO SERVER FIXTURES
|
||||
# ============================================================================
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def sio_server():
|
||||
"""
|
||||
Create a bare Socket.io AsyncServer for handler registration.
|
||||
|
||||
Use this when you need to control patching manually.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
return AsyncServer()
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def sio_with_mocks(mock_manager, mock_state_manager, mock_game_engine, mock_dice_system):
|
||||
"""
|
||||
Create Socket.io server with handlers registered and all dependencies mocked.
|
||||
|
||||
This fixture patches all singletons BEFORE registering handlers to ensure
|
||||
the handlers capture the mocked versions in their closures.
|
||||
|
||||
Returns a tuple of (sio, patches_dict) where patches_dict contains the
|
||||
mock objects for additional configuration in tests.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.state_manager", mock_state_manager), \
|
||||
patch("app.websocket.handlers.game_engine", mock_game_engine), \
|
||||
patch("app.websocket.handlers.dice_system", mock_dice_system):
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
yield sio, {
|
||||
"manager": mock_manager,
|
||||
"state_manager": mock_state_manager,
|
||||
"game_engine": mock_game_engine,
|
||||
"dice_system": mock_dice_system,
|
||||
}
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# UTILITY FUNCTIONS
|
||||
# ============================================================================
|
||||
|
||||
|
||||
def get_handler(sio, handler_name: str):
|
||||
"""
|
||||
Get a specific event handler from the Socket.io server.
|
||||
|
||||
Args:
|
||||
sio: AsyncServer instance with registered handlers
|
||||
handler_name: Name of the event handler (e.g., 'roll_dice')
|
||||
|
||||
Returns:
|
||||
The async handler function
|
||||
"""
|
||||
return sio.handlers["/"][handler_name]
|
||||
|
||||
|
||||
def assert_error_emitted(mock_manager, expected_message_substring: str):
|
||||
"""
|
||||
Assert that an error was emitted to the user.
|
||||
|
||||
Args:
|
||||
mock_manager: The mock ConnectionManager
|
||||
expected_message_substring: Text that should appear in error message
|
||||
"""
|
||||
mock_manager.emit_to_user.assert_called()
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
event_name = call_args[0][1]
|
||||
data = call_args[0][2]
|
||||
|
||||
assert event_name in ("error", "substitution_error", "outcome_rejected"), \
|
||||
f"Expected error event, got {event_name}"
|
||||
assert expected_message_substring in data.get("message", ""), \
|
||||
f"Expected '{expected_message_substring}' in message, got: {data}"
|
||||
|
||||
|
||||
def assert_broadcast_sent(mock_manager, event_name: str, game_id: str = None):
|
||||
"""
|
||||
Assert that a broadcast was sent to the game room.
|
||||
|
||||
Args:
|
||||
mock_manager: The mock ConnectionManager
|
||||
event_name: Expected event name (e.g., 'dice_rolled')
|
||||
game_id: Optional game ID to verify destination
|
||||
"""
|
||||
mock_manager.broadcast_to_game.assert_called()
|
||||
call_args = mock_manager.broadcast_to_game.call_args
|
||||
actual_event = call_args[0][1]
|
||||
|
||||
assert actual_event == event_name, \
|
||||
f"Expected broadcast event '{event_name}', got '{actual_event}'"
|
||||
|
||||
if game_id:
|
||||
actual_game_id = call_args[0][0]
|
||||
assert actual_game_id == game_id, \
|
||||
f"Expected game_id '{game_id}', got '{actual_game_id}'"
|
||||
716
backend/tests/unit/websocket/test_connection_handlers.py
Normal file
716
backend/tests/unit/websocket/test_connection_handlers.py
Normal file
@ -0,0 +1,716 @@
|
||||
"""
|
||||
Tests for WebSocket connection and room management handlers.
|
||||
|
||||
Verifies authentication (connect), disconnection (disconnect), room joining
|
||||
(join_game, leave_game), heartbeat, and game state request handlers.
|
||||
|
||||
Author: Claude
|
||||
Date: 2025-01-27
|
||||
"""
|
||||
|
||||
import pytest
|
||||
from uuid import uuid4
|
||||
from unittest.mock import AsyncMock, MagicMock, patch
|
||||
|
||||
from tests.unit.websocket.conftest import get_handler
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# CONNECT HANDLER TESTS
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class TestConnectHandler:
|
||||
"""Tests for the connect event handler."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_connect_with_valid_cookie(self, mock_manager):
|
||||
"""
|
||||
Verify connect() accepts connection with valid cookie token.
|
||||
|
||||
Cookie-based auth is the primary auth method when using HttpOnly cookies
|
||||
set by the OAuth flow. Handler should extract token from HTTP_COOKIE.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
# Mock verify_token to return valid user data
|
||||
with patch("app.websocket.handlers.verify_token") as mock_verify:
|
||||
mock_verify.return_value = {"user_id": "user_123", "username": "testuser"}
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["connect"]
|
||||
|
||||
# Simulate environ with cookie
|
||||
environ = {"HTTP_COOKIE": "pd_access_token=valid_token_here; other=value"}
|
||||
auth = None
|
||||
|
||||
result = await handler("test_sid", environ, auth)
|
||||
|
||||
assert result is True
|
||||
mock_manager.connect.assert_called_once_with("test_sid", "user_123", ip_address=None)
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_connect_with_auth_object(self, mock_manager):
|
||||
"""
|
||||
Verify connect() accepts connection with auth object token.
|
||||
|
||||
Auth object is used by direct JS clients that can't use cookies.
|
||||
Handler should fall back to auth.token when cookie not present.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.verify_token") as mock_verify:
|
||||
mock_verify.return_value = {"user_id": "user_456", "username": "jsuser"}
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["connect"]
|
||||
|
||||
# Simulate environ without cookie, but with auth object
|
||||
environ = {"HTTP_COOKIE": ""}
|
||||
auth = {"token": "auth_object_token"}
|
||||
|
||||
result = await handler("test_sid", environ, auth)
|
||||
|
||||
assert result is True
|
||||
mock_verify.assert_called_once_with("auth_object_token")
|
||||
mock_manager.connect.assert_called_once_with("test_sid", "user_456", ip_address=None)
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_connect_missing_credentials_rejected(self, mock_manager):
|
||||
"""
|
||||
Verify connect() rejects connection when no token provided.
|
||||
|
||||
Handler should return False to reject the Socket.io connection
|
||||
when neither cookie nor auth object contains a token.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["connect"]
|
||||
|
||||
# No cookie, no auth
|
||||
environ = {"HTTP_COOKIE": ""}
|
||||
auth = None
|
||||
|
||||
result = await handler("test_sid", environ, auth)
|
||||
|
||||
assert result is False
|
||||
mock_manager.connect.assert_not_called()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_connect_invalid_token_rejected(self, mock_manager):
|
||||
"""
|
||||
Verify connect() rejects connection when token is invalid.
|
||||
|
||||
When verify_token returns no user_id, the connection should be rejected.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.verify_token") as mock_verify:
|
||||
mock_verify.return_value = {} # No user_id in response
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["connect"]
|
||||
|
||||
environ = {"HTTP_COOKIE": "pd_access_token=invalid_token"}
|
||||
auth = None
|
||||
|
||||
result = await handler("test_sid", environ, auth)
|
||||
|
||||
assert result is False
|
||||
mock_manager.connect.assert_not_called()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_connect_exception_rejected(self, mock_manager):
|
||||
"""
|
||||
Verify connect() rejects connection when exception occurs.
|
||||
|
||||
Any exception during auth processing should result in connection rejection,
|
||||
not a server crash.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.verify_token") as mock_verify:
|
||||
mock_verify.side_effect = Exception("Token verification failed")
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["connect"]
|
||||
|
||||
environ = {"HTTP_COOKIE": "pd_access_token=error_token"}
|
||||
auth = None
|
||||
|
||||
result = await handler("test_sid", environ, auth)
|
||||
|
||||
assert result is False
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_connect_extracts_ip_address(self, mock_manager):
|
||||
"""
|
||||
Verify connect() extracts IP address from environ.
|
||||
|
||||
IP address is used for logging and rate limiting. Handler should
|
||||
extract REMOTE_ADDR from the WSGI environ dict.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.verify_token") as mock_verify:
|
||||
mock_verify.return_value = {"user_id": "user_123"}
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["connect"]
|
||||
|
||||
environ = {
|
||||
"HTTP_COOKIE": "pd_access_token=valid_token",
|
||||
"REMOTE_ADDR": "192.168.1.100",
|
||||
}
|
||||
|
||||
result = await handler("test_sid", environ, None)
|
||||
|
||||
assert result is True
|
||||
mock_manager.connect.assert_called_once_with(
|
||||
"test_sid", "user_123", ip_address="192.168.1.100"
|
||||
)
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_connect_emits_connected_event(self, mock_manager):
|
||||
"""
|
||||
Verify connect() emits connected event with user_id.
|
||||
|
||||
After successful authentication, the handler should emit a 'connected'
|
||||
event to the client with their user_id for client-side tracking.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
sio.emit = AsyncMock()
|
||||
|
||||
with patch("app.websocket.handlers.verify_token") as mock_verify:
|
||||
mock_verify.return_value = {"user_id": "user_789"}
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["connect"]
|
||||
|
||||
environ = {"HTTP_COOKIE": "pd_access_token=valid_token"}
|
||||
|
||||
await handler("test_sid", environ, None)
|
||||
|
||||
# Verify connected event emitted
|
||||
sio.emit.assert_called_once()
|
||||
call_args = sio.emit.call_args
|
||||
assert call_args[0][0] == "connected"
|
||||
assert call_args[0][1]["user_id"] == "user_789"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_connect_value_error_rejected(self, mock_manager):
|
||||
"""
|
||||
Verify connect() handles ValueError during token parsing.
|
||||
|
||||
If verify_token raises ValueError (malformed token), the connection
|
||||
should be rejected without crashing.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.verify_token") as mock_verify:
|
||||
mock_verify.side_effect = ValueError("Invalid token format")
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["connect"]
|
||||
|
||||
environ = {"HTTP_COOKIE": "pd_access_token=malformed"}
|
||||
result = await handler("test_sid", environ, None)
|
||||
|
||||
assert result is False
|
||||
mock_manager.connect.assert_not_called()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_connect_key_error_rejected(self, mock_manager):
|
||||
"""
|
||||
Verify connect() handles KeyError during token parsing.
|
||||
|
||||
If verify_token raises KeyError (missing required field), the connection
|
||||
should be rejected without crashing.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.verify_token") as mock_verify:
|
||||
mock_verify.side_effect = KeyError("missing_field")
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["connect"]
|
||||
|
||||
environ = {"HTTP_COOKIE": "pd_access_token=incomplete"}
|
||||
result = await handler("test_sid", environ, None)
|
||||
|
||||
assert result is False
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_connect_network_error_rejected(self, mock_manager):
|
||||
"""
|
||||
Verify connect() handles network errors gracefully.
|
||||
|
||||
If a ConnectionError or OSError occurs during connection setup,
|
||||
the connection should be rejected.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.verify_token") as mock_verify:
|
||||
mock_verify.return_value = {"user_id": "user_123"}
|
||||
mock_manager.connect = AsyncMock(side_effect=ConnectionError("Network failed"))
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["connect"]
|
||||
|
||||
environ = {"HTTP_COOKIE": "pd_access_token=valid"}
|
||||
result = await handler("test_sid", environ, None)
|
||||
|
||||
assert result is False
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# DISCONNECT HANDLER TESTS
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class TestDisconnectHandler:
|
||||
"""Tests for the disconnect event handler."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_disconnect_calls_manager(self, mock_manager):
|
||||
"""
|
||||
Verify disconnect() delegates to ConnectionManager.
|
||||
|
||||
Handler should call manager.disconnect() with the session ID
|
||||
to clean up all session state and room memberships.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["disconnect"]
|
||||
|
||||
await handler("test_sid")
|
||||
|
||||
mock_manager.disconnect.assert_called_once_with("test_sid")
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_disconnect_cleans_rate_limiter(self, mock_manager):
|
||||
"""
|
||||
Verify disconnect() removes rate limiter buckets.
|
||||
|
||||
Handler should call rate_limiter.remove_connection() to clean up
|
||||
rate limiting state and prevent memory leaks.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.rate_limiter") as mock_limiter:
|
||||
mock_limiter.remove_connection = MagicMock()
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["disconnect"]
|
||||
|
||||
await handler("test_sid")
|
||||
|
||||
mock_limiter.remove_connection.assert_called_once_with("test_sid")
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_disconnect_handles_manager_error(self, mock_manager):
|
||||
"""
|
||||
Verify disconnect() handles manager errors gracefully.
|
||||
|
||||
Even if manager.disconnect() raises an error, the handler should
|
||||
not crash - disconnection cleanup should be best-effort.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
mock_manager.disconnect = AsyncMock(side_effect=Exception("Cleanup failed"))
|
||||
|
||||
with patch("app.websocket.handlers.rate_limiter"):
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["disconnect"]
|
||||
|
||||
# Should not raise even if manager fails
|
||||
# Note: The handler may or may not catch this - depends on impl
|
||||
try:
|
||||
await handler("test_sid")
|
||||
except Exception:
|
||||
pass # Some implementations may let errors propagate
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_disconnect_multiple_calls_idempotent(self, mock_manager):
|
||||
"""
|
||||
Verify disconnect() can be called multiple times safely.
|
||||
|
||||
Socket.io may call disconnect multiple times in edge cases.
|
||||
Handler should be idempotent and not crash on repeated calls.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.rate_limiter"):
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["disconnect"]
|
||||
|
||||
# First disconnect
|
||||
await handler("test_sid")
|
||||
# Second disconnect should also succeed
|
||||
await handler("test_sid")
|
||||
|
||||
# Manager should be called twice
|
||||
assert mock_manager.disconnect.call_count == 2
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# JOIN GAME HANDLER TESTS
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class TestJoinGameHandler:
|
||||
"""Tests for the join_game event handler."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_join_game_success(self, mock_manager):
|
||||
"""
|
||||
Verify join_game() successfully joins user to game room.
|
||||
|
||||
Handler should call manager.join_game and emit game_joined confirmation.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["join_game"]
|
||||
|
||||
game_id = str(uuid4())
|
||||
await handler("test_sid", {"game_id": game_id})
|
||||
|
||||
mock_manager.join_game.assert_called_once_with("test_sid", game_id, "player")
|
||||
mock_manager.emit_to_user.assert_called_once()
|
||||
|
||||
# Verify confirmation event
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "game_joined"
|
||||
assert call_args[0][2]["game_id"] == game_id
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_join_game_missing_game_id(self, mock_manager):
|
||||
"""
|
||||
Verify join_game() returns error when game_id missing.
|
||||
|
||||
Handler should emit error event without attempting to join.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["join_game"]
|
||||
|
||||
await handler("test_sid", {})
|
||||
|
||||
mock_manager.join_game.assert_not_called()
|
||||
mock_manager.emit_to_user.assert_called_once()
|
||||
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "error"
|
||||
assert "game_id" in call_args[0][2]["message"].lower()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_join_game_with_role(self, mock_manager):
|
||||
"""
|
||||
Verify join_game() passes role to manager.
|
||||
|
||||
Role can be 'home', 'away', 'spectator', or 'player'.
|
||||
Handler should pass the specified role to manager.join_game().
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["join_game"]
|
||||
|
||||
game_id = str(uuid4())
|
||||
await handler("test_sid", {"game_id": game_id, "role": "spectator"})
|
||||
|
||||
mock_manager.join_game.assert_called_once_with("test_sid", game_id, "spectator")
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# LEAVE GAME HANDLER TESTS
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class TestLeaveGameHandler:
|
||||
"""Tests for the leave_game event handler."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_leave_game_success(self, mock_manager):
|
||||
"""
|
||||
Verify leave_game() removes user from game room.
|
||||
|
||||
Handler should call manager.leave_game with game_id.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["leave_game"]
|
||||
|
||||
game_id = str(uuid4())
|
||||
await handler("test_sid", {"game_id": game_id})
|
||||
|
||||
mock_manager.leave_game.assert_called_once_with("test_sid", game_id)
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_leave_game_missing_game_id_noop(self, mock_manager):
|
||||
"""
|
||||
Verify leave_game() is a no-op when game_id missing.
|
||||
|
||||
Handler should not call leave_game if no game_id provided.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["leave_game"]
|
||||
|
||||
await handler("test_sid", {})
|
||||
|
||||
mock_manager.leave_game.assert_not_called()
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# HEARTBEAT HANDLER TESTS
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class TestHeartbeatHandler:
|
||||
"""Tests for the heartbeat event handler."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_heartbeat_acknowledges(self, mock_manager):
|
||||
"""
|
||||
Verify heartbeat() emits acknowledgment.
|
||||
|
||||
Handler should emit heartbeat_ack directly to the client socket.
|
||||
This keeps the connection alive and verifies client is responsive.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
sio.emit = AsyncMock()
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["heartbeat"]
|
||||
|
||||
await handler("test_sid")
|
||||
|
||||
sio.emit.assert_called_once_with("heartbeat_ack", {}, room="test_sid")
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# REQUEST GAME STATE HANDLER TESTS
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class TestRequestGameStateHandler:
|
||||
"""Tests for the request_game_state event handler."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_request_game_state_from_memory(self, mock_manager, mock_game_state):
|
||||
"""
|
||||
Verify request_game_state() returns state from memory.
|
||||
|
||||
When game state is in StateManager memory, handler should return it
|
||||
directly without hitting the database (fast path).
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_game_state"]
|
||||
|
||||
await handler("test_sid", {"game_id": str(mock_game_state.game_id)})
|
||||
|
||||
mock_state_mgr.get_state.assert_called_once()
|
||||
mock_state_mgr.recover_game.assert_not_called()
|
||||
mock_manager.emit_to_user.assert_called_once()
|
||||
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "game_state"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_request_game_state_from_db(self, mock_manager, mock_game_state):
|
||||
"""
|
||||
Verify request_game_state() recovers from database when not in memory.
|
||||
|
||||
When game state is not in memory, handler should call recover_game()
|
||||
to load and replay from database (recovery path).
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
mock_state_mgr.get_state.return_value = None # Not in memory
|
||||
mock_state_mgr.recover_game = AsyncMock(return_value=mock_game_state)
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_game_state"]
|
||||
|
||||
await handler("test_sid", {"game_id": str(mock_game_state.game_id)})
|
||||
|
||||
mock_state_mgr.get_state.assert_called_once()
|
||||
mock_state_mgr.recover_game.assert_called_once()
|
||||
mock_manager.emit_to_user.assert_called_once()
|
||||
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "game_state"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_request_game_state_missing_game_id(self, mock_manager):
|
||||
"""
|
||||
Verify request_game_state() returns error when game_id missing.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_game_state"]
|
||||
|
||||
await handler("test_sid", {})
|
||||
|
||||
mock_manager.emit_to_user.assert_called_once()
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "error"
|
||||
assert "game_id" in call_args[0][2]["message"].lower()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_request_game_state_invalid_format(self, mock_manager):
|
||||
"""
|
||||
Verify request_game_state() returns error for invalid UUID format.
|
||||
|
||||
Handler should validate game_id is a valid UUID before attempting
|
||||
to fetch state.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_game_state"]
|
||||
|
||||
await handler("test_sid", {"game_id": "not-a-valid-uuid"})
|
||||
|
||||
mock_manager.emit_to_user.assert_called_once()
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "error"
|
||||
assert "invalid" in call_args[0][2]["message"].lower()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_request_game_state_not_found(self, mock_manager):
|
||||
"""
|
||||
Verify request_game_state() returns error when game not found anywhere.
|
||||
|
||||
When game is neither in memory nor database, handler should emit
|
||||
an error event indicating the game was not found.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
mock_state_mgr.get_state.return_value = None
|
||||
mock_state_mgr.recover_game = AsyncMock(return_value=None)
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_game_state"]
|
||||
|
||||
game_id = str(uuid4())
|
||||
await handler("test_sid", {"game_id": game_id})
|
||||
|
||||
mock_manager.emit_to_user.assert_called_once()
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "error"
|
||||
assert "not found" in call_args[0][2]["message"].lower()
|
||||
817
backend/tests/unit/websocket/test_connection_manager.py
Normal file
817
backend/tests/unit/websocket/test_connection_manager.py
Normal file
@ -0,0 +1,817 @@
|
||||
"""
|
||||
Tests for ConnectionManager class.
|
||||
|
||||
Verifies session management, room membership, event broadcasting,
|
||||
and session expiration functionality that forms the foundation of
|
||||
real-time WebSocket communication.
|
||||
|
||||
Author: Claude
|
||||
Date: 2025-01-27
|
||||
Updated: 2025-01-27 - Added session expiration tests
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import pytest
|
||||
from unittest.mock import AsyncMock, MagicMock, patch
|
||||
|
||||
import pendulum
|
||||
|
||||
from app.websocket.connection_manager import ConnectionManager, SessionInfo
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# CONNECTION TESTS
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class TestConnect:
|
||||
"""Tests for connection registration."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_connect_registers_session(self):
|
||||
"""
|
||||
Verify connect() stores user_id in user_sessions dict.
|
||||
|
||||
The session ID (sid) should map to the user_id for later lookups.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
await manager.connect("sid_123", "user_456")
|
||||
|
||||
assert "sid_123" in manager.user_sessions
|
||||
assert manager.user_sessions["sid_123"] == "user_456"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_connect_duplicate_sid_replaces(self):
|
||||
"""
|
||||
Verify connecting with same SID replaces existing user_id.
|
||||
|
||||
This handles reconnection scenarios where the same socket reconnects
|
||||
with a different user (edge case).
|
||||
"""
|
||||
sio = MagicMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
await manager.connect("sid_123", "user_A")
|
||||
await manager.connect("sid_123", "user_B")
|
||||
|
||||
assert manager.user_sessions["sid_123"] == "user_B"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_connect_multiple_users(self):
|
||||
"""Verify multiple users can connect simultaneously."""
|
||||
sio = MagicMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
await manager.connect("sid_1", "user_1")
|
||||
await manager.connect("sid_2", "user_2")
|
||||
await manager.connect("sid_3", "user_3")
|
||||
|
||||
assert len(manager.user_sessions) == 3
|
||||
assert manager.user_sessions["sid_1"] == "user_1"
|
||||
assert manager.user_sessions["sid_2"] == "user_2"
|
||||
assert manager.user_sessions["sid_3"] == "user_3"
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# DISCONNECT TESTS
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class TestDisconnect:
|
||||
"""Tests for disconnection handling."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_disconnect_removes_session(self):
|
||||
"""
|
||||
Verify disconnect() removes user from user_sessions dict.
|
||||
|
||||
After disconnection, the SID should no longer be tracked.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
sio.emit = AsyncMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
await manager.connect("sid_123", "user_456")
|
||||
await manager.disconnect("sid_123")
|
||||
|
||||
assert "sid_123" not in manager.user_sessions
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_disconnect_removes_from_all_rooms(self):
|
||||
"""
|
||||
Verify disconnect() removes user from all game rooms they joined.
|
||||
|
||||
User should be cleaned up from every game room to prevent stale
|
||||
participants.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
sio.enter_room = AsyncMock()
|
||||
sio.emit = AsyncMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
# Connect and join multiple games
|
||||
await manager.connect("sid_123", "user_456")
|
||||
await manager.join_game("sid_123", "game_A", "home")
|
||||
await manager.join_game("sid_123", "game_B", "away")
|
||||
|
||||
# Verify in both rooms
|
||||
assert "sid_123" in manager.game_rooms["game_A"]
|
||||
assert "sid_123" in manager.game_rooms["game_B"]
|
||||
|
||||
# Disconnect
|
||||
await manager.disconnect("sid_123")
|
||||
|
||||
# Should be removed from all rooms
|
||||
assert "sid_123" not in manager.game_rooms["game_A"]
|
||||
assert "sid_123" not in manager.game_rooms["game_B"]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_disconnect_nonexistent_noop(self):
|
||||
"""
|
||||
Verify disconnecting unknown SID is a safe no-op.
|
||||
|
||||
Should not raise exception when SID was never connected.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
# Should not raise
|
||||
await manager.disconnect("unknown_sid")
|
||||
|
||||
assert "unknown_sid" not in manager.user_sessions
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_disconnect_broadcasts_to_rooms(self):
|
||||
"""
|
||||
Verify disconnect() broadcasts user_disconnected to game rooms.
|
||||
|
||||
Other participants in the game should be notified when a user leaves.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
sio.enter_room = AsyncMock()
|
||||
sio.emit = AsyncMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
await manager.connect("sid_123", "user_456")
|
||||
await manager.join_game("sid_123", "game_A", "home")
|
||||
|
||||
# Clear previous emit calls
|
||||
sio.emit.reset_mock()
|
||||
|
||||
await manager.disconnect("sid_123")
|
||||
|
||||
# Should broadcast user_disconnected
|
||||
sio.emit.assert_called()
|
||||
call_args = sio.emit.call_args_list[-1]
|
||||
assert call_args[0][0] == "user_disconnected"
|
||||
assert call_args[0][1]["user_id"] == "user_456"
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# ROOM MANAGEMENT TESTS
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class TestRoomManagement:
|
||||
"""Tests for game room join/leave functionality."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_join_game_creates_room(self):
|
||||
"""
|
||||
Verify join_game() creates room entry if game doesn't exist.
|
||||
|
||||
First user joining a game should create the room tracking.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
sio.enter_room = AsyncMock()
|
||||
sio.emit = AsyncMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
await manager.connect("sid_123", "user_456")
|
||||
await manager.join_game("sid_123", "game_A", "home")
|
||||
|
||||
assert "game_A" in manager.game_rooms
|
||||
assert "sid_123" in manager.game_rooms["game_A"]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_join_game_adds_to_existing(self):
|
||||
"""
|
||||
Verify join_game() adds to existing room.
|
||||
|
||||
Multiple users can join the same game room.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
sio.enter_room = AsyncMock()
|
||||
sio.emit = AsyncMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
await manager.connect("sid_1", "user_1")
|
||||
await manager.connect("sid_2", "user_2")
|
||||
|
||||
await manager.join_game("sid_1", "game_A", "home")
|
||||
await manager.join_game("sid_2", "game_A", "away")
|
||||
|
||||
assert len(manager.game_rooms["game_A"]) == 2
|
||||
assert "sid_1" in manager.game_rooms["game_A"]
|
||||
assert "sid_2" in manager.game_rooms["game_A"]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_join_game_enters_socketio_room(self):
|
||||
"""
|
||||
Verify join_game() calls Socket.io enter_room.
|
||||
|
||||
Must register with Socket.io's room system for broadcasting to work.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
sio.enter_room = AsyncMock()
|
||||
sio.emit = AsyncMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
await manager.connect("sid_123", "user_456")
|
||||
await manager.join_game("sid_123", "game_A", "home")
|
||||
|
||||
sio.enter_room.assert_called_once_with("sid_123", "game_A")
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_join_game_broadcasts_user_connected(self):
|
||||
"""
|
||||
Verify join_game() broadcasts user_connected to the room.
|
||||
|
||||
Other participants should be notified when a new user joins.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
sio.enter_room = AsyncMock()
|
||||
sio.emit = AsyncMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
await manager.connect("sid_123", "user_456")
|
||||
await manager.join_game("sid_123", "game_A", "home")
|
||||
|
||||
# Should broadcast user_connected
|
||||
sio.emit.assert_called()
|
||||
call_args = sio.emit.call_args
|
||||
assert call_args[0][0] == "user_connected"
|
||||
assert call_args[0][1]["user_id"] == "user_456"
|
||||
assert call_args[0][1]["role"] == "home"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_leave_game_removes_from_room(self):
|
||||
"""
|
||||
Verify leave_game() removes user from specific game room.
|
||||
|
||||
User should only be removed from the specified game.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
sio.enter_room = AsyncMock()
|
||||
sio.leave_room = AsyncMock()
|
||||
sio.emit = AsyncMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
await manager.connect("sid_123", "user_456")
|
||||
await manager.join_game("sid_123", "game_A", "home")
|
||||
await manager.join_game("sid_123", "game_B", "away")
|
||||
|
||||
await manager.leave_game("sid_123", "game_A")
|
||||
|
||||
assert "sid_123" not in manager.game_rooms["game_A"]
|
||||
assert "sid_123" in manager.game_rooms["game_B"]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_leave_game_leaves_socketio_room(self):
|
||||
"""
|
||||
Verify leave_game() calls Socket.io leave_room.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
sio.enter_room = AsyncMock()
|
||||
sio.leave_room = AsyncMock()
|
||||
sio.emit = AsyncMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
await manager.connect("sid_123", "user_456")
|
||||
await manager.join_game("sid_123", "game_A", "home")
|
||||
await manager.leave_game("sid_123", "game_A")
|
||||
|
||||
sio.leave_room.assert_called_once_with("sid_123", "game_A")
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_game_participants(self):
|
||||
"""
|
||||
Verify get_game_participants() returns all SIDs in room.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
sio.enter_room = AsyncMock()
|
||||
sio.emit = AsyncMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
await manager.connect("sid_1", "user_1")
|
||||
await manager.connect("sid_2", "user_2")
|
||||
await manager.join_game("sid_1", "game_A", "home")
|
||||
await manager.join_game("sid_2", "game_A", "away")
|
||||
|
||||
participants = manager.get_game_participants("game_A")
|
||||
|
||||
assert len(participants) == 2
|
||||
assert "sid_1" in participants
|
||||
assert "sid_2" in participants
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_game_participants_empty_room(self):
|
||||
"""
|
||||
Verify get_game_participants() returns empty set for unknown game.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
participants = manager.get_game_participants("nonexistent_game")
|
||||
|
||||
assert participants == set()
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# BROADCASTING TESTS
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class TestBroadcasting:
|
||||
"""Tests for event emission functionality."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_broadcast_to_game_emits_to_room(self):
|
||||
"""
|
||||
Verify broadcast_to_game() emits to the correct Socket.io room.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
sio.emit = AsyncMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
await manager.broadcast_to_game("game_A", "test_event", {"key": "value"})
|
||||
|
||||
sio.emit.assert_called_once_with(
|
||||
"test_event", {"key": "value"}, room="game_A"
|
||||
)
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_broadcast_to_empty_room_noop(self):
|
||||
"""
|
||||
Verify broadcasting to empty room doesn't raise exception.
|
||||
|
||||
Socket.io handles empty rooms gracefully - we just emit.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
sio.emit = AsyncMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
# Should not raise
|
||||
await manager.broadcast_to_game("empty_game", "event", {})
|
||||
|
||||
sio.emit.assert_called_once()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_emit_to_user_targets_sid(self):
|
||||
"""
|
||||
Verify emit_to_user() sends to specific session ID.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
sio.emit = AsyncMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
await manager.emit_to_user("sid_123", "private_event", {"secret": "data"})
|
||||
|
||||
sio.emit.assert_called_once_with(
|
||||
"private_event", {"secret": "data"}, room="sid_123"
|
||||
)
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_emit_to_user_vs_broadcast_isolation(self):
|
||||
"""
|
||||
Verify emit_to_user and broadcast_to_game are independent.
|
||||
|
||||
Private message should not go to game room, and vice versa.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
sio.emit = AsyncMock()
|
||||
sio.enter_room = AsyncMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
await manager.connect("sid_123", "user_456")
|
||||
await manager.join_game("sid_123", "game_A", "home")
|
||||
|
||||
# Clear previous emits
|
||||
sio.emit.reset_mock()
|
||||
|
||||
# Send private message
|
||||
await manager.emit_to_user("sid_123", "private", {"data": 1})
|
||||
|
||||
# Verify it went to sid, not game room
|
||||
call_args = sio.emit.call_args
|
||||
assert call_args[1]["room"] == "sid_123" # Not "game_A"
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# SESSION INFO TESTS
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class TestSessionInfo:
|
||||
"""Tests for SessionInfo dataclass."""
|
||||
|
||||
def test_session_info_creates_with_defaults(self):
|
||||
"""
|
||||
Verify SessionInfo creates with required fields and defaults.
|
||||
|
||||
games should default to empty set, ip_address to None.
|
||||
"""
|
||||
now = pendulum.now("UTC")
|
||||
info = SessionInfo(
|
||||
user_id="user_123",
|
||||
connected_at=now,
|
||||
last_activity=now,
|
||||
)
|
||||
|
||||
assert info.user_id == "user_123"
|
||||
assert info.connected_at == now
|
||||
assert info.last_activity == now
|
||||
assert info.games == set()
|
||||
assert info.ip_address is None
|
||||
|
||||
def test_session_info_with_ip_address(self):
|
||||
"""Verify SessionInfo stores IP address when provided."""
|
||||
now = pendulum.now("UTC")
|
||||
info = SessionInfo(
|
||||
user_id="user_123",
|
||||
connected_at=now,
|
||||
last_activity=now,
|
||||
ip_address="192.168.1.100",
|
||||
)
|
||||
|
||||
assert info.ip_address == "192.168.1.100"
|
||||
|
||||
def test_inactive_seconds_fresh_session(self):
|
||||
"""
|
||||
Verify inactive_seconds returns near-zero for fresh session.
|
||||
|
||||
A session just created should have very low inactivity.
|
||||
"""
|
||||
now = pendulum.now("UTC")
|
||||
info = SessionInfo(
|
||||
user_id="user_123",
|
||||
connected_at=now,
|
||||
last_activity=now,
|
||||
)
|
||||
|
||||
# Should be very close to 0 (within 1 second)
|
||||
assert info.inactive_seconds() < 1.0
|
||||
|
||||
def test_inactive_seconds_old_session(self):
|
||||
"""
|
||||
Verify inactive_seconds returns correct duration for old session.
|
||||
|
||||
A session inactive for 5 minutes should report ~300 seconds.
|
||||
"""
|
||||
now = pendulum.now("UTC")
|
||||
five_min_ago = now.subtract(minutes=5)
|
||||
info = SessionInfo(
|
||||
user_id="user_123",
|
||||
connected_at=five_min_ago,
|
||||
last_activity=five_min_ago,
|
||||
)
|
||||
|
||||
# Should be approximately 300 seconds (allow some tolerance)
|
||||
inactive = info.inactive_seconds()
|
||||
assert 299.0 < inactive < 302.0
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# SESSION ACTIVITY TESTS
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class TestSessionActivity:
|
||||
"""Tests for session activity tracking."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_update_activity_refreshes_timestamp(self):
|
||||
"""
|
||||
Verify update_activity() refreshes last_activity timestamp.
|
||||
|
||||
After calling update_activity, the session should show recent activity.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
await manager.connect("sid_123", "user_456")
|
||||
|
||||
# Get original timestamp
|
||||
session = manager.get_session("sid_123")
|
||||
original_activity = session.last_activity
|
||||
|
||||
# Small delay to ensure time difference
|
||||
await asyncio.sleep(0.01)
|
||||
|
||||
# Update activity
|
||||
await manager.update_activity("sid_123")
|
||||
|
||||
# Timestamp should be updated
|
||||
updated_session = manager.get_session("sid_123")
|
||||
assert updated_session.last_activity > original_activity
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_update_activity_unknown_sid_noop(self):
|
||||
"""
|
||||
Verify update_activity() for unknown SID is safe no-op.
|
||||
|
||||
Should not raise exception for non-existent session.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
# Should not raise
|
||||
await manager.update_activity("unknown_sid")
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_session_returns_info(self):
|
||||
"""
|
||||
Verify get_session() returns SessionInfo for valid SID.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
await manager.connect("sid_123", "user_456", ip_address="10.0.0.1")
|
||||
|
||||
session = manager.get_session("sid_123")
|
||||
|
||||
assert session is not None
|
||||
assert session.user_id == "user_456"
|
||||
assert session.ip_address == "10.0.0.1"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_session_unknown_returns_none(self):
|
||||
"""
|
||||
Verify get_session() returns None for unknown SID.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
session = manager.get_session("unknown_sid")
|
||||
|
||||
assert session is None
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_user_id_returns_user(self):
|
||||
"""
|
||||
Verify get_user_id() returns user_id for valid SID.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
await manager.connect("sid_123", "user_456")
|
||||
|
||||
user_id = manager.get_user_id("sid_123")
|
||||
|
||||
assert user_id == "user_456"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_user_id_unknown_returns_none(self):
|
||||
"""
|
||||
Verify get_user_id() returns None for unknown SID.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
user_id = manager.get_user_id("unknown_sid")
|
||||
|
||||
assert user_id is None
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# SESSION EXPIRATION TESTS
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class TestSessionExpiration:
|
||||
"""Tests for session expiration functionality."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_expire_inactive_sessions_removes_old(self):
|
||||
"""
|
||||
Verify expire_inactive_sessions() removes sessions beyond timeout.
|
||||
|
||||
Sessions inactive longer than timeout should be disconnected.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
sio.emit = AsyncMock()
|
||||
sio.disconnect = AsyncMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
await manager.connect("sid_123", "user_456")
|
||||
|
||||
# Manually set session to be old
|
||||
manager._sessions["sid_123"].last_activity = pendulum.now("UTC").subtract(minutes=10)
|
||||
|
||||
# Expire with 5 minute timeout
|
||||
expired = await manager.expire_inactive_sessions(timeout_seconds=300)
|
||||
|
||||
assert "sid_123" in expired
|
||||
assert "sid_123" not in manager._sessions
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_expire_inactive_sessions_keeps_active(self):
|
||||
"""
|
||||
Verify expire_inactive_sessions() keeps recently active sessions.
|
||||
|
||||
Sessions with recent activity should not be expired.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
sio.emit = AsyncMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
await manager.connect("sid_123", "user_456")
|
||||
await manager.update_activity("sid_123") # Fresh activity
|
||||
|
||||
# Expire with 5 minute timeout
|
||||
expired = await manager.expire_inactive_sessions(timeout_seconds=300)
|
||||
|
||||
assert "sid_123" not in expired
|
||||
assert "sid_123" in manager._sessions
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_expire_inactive_calls_socketio_disconnect(self):
|
||||
"""
|
||||
Verify expire_inactive_sessions() calls Socket.io disconnect.
|
||||
|
||||
Expired sessions should be forcefully disconnected from Socket.io.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
sio.emit = AsyncMock()
|
||||
sio.disconnect = AsyncMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
await manager.connect("sid_123", "user_456")
|
||||
manager._sessions["sid_123"].last_activity = pendulum.now("UTC").subtract(minutes=10)
|
||||
|
||||
await manager.expire_inactive_sessions(timeout_seconds=300)
|
||||
|
||||
sio.disconnect.assert_called_once_with("sid_123")
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_expire_inactive_handles_disconnect_error(self):
|
||||
"""
|
||||
Verify expire_inactive_sessions() handles Socket.io disconnect errors.
|
||||
|
||||
Should not raise if Socket.io disconnect fails (connection may already be gone).
|
||||
"""
|
||||
sio = MagicMock()
|
||||
sio.emit = AsyncMock()
|
||||
sio.disconnect = AsyncMock(side_effect=Exception("Already disconnected"))
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
await manager.connect("sid_123", "user_456")
|
||||
manager._sessions["sid_123"].last_activity = pendulum.now("UTC").subtract(minutes=10)
|
||||
|
||||
# Should not raise
|
||||
expired = await manager.expire_inactive_sessions(timeout_seconds=300)
|
||||
|
||||
assert "sid_123" in expired
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_expire_returns_list_of_expired_sids(self):
|
||||
"""
|
||||
Verify expire_inactive_sessions() returns list of expired session IDs.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
sio.emit = AsyncMock()
|
||||
sio.disconnect = AsyncMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
# Connect multiple sessions
|
||||
await manager.connect("sid_1", "user_1")
|
||||
await manager.connect("sid_2", "user_2")
|
||||
await manager.connect("sid_3", "user_3")
|
||||
|
||||
# Make only some sessions old
|
||||
manager._sessions["sid_1"].last_activity = pendulum.now("UTC").subtract(minutes=10)
|
||||
manager._sessions["sid_3"].last_activity = pendulum.now("UTC").subtract(minutes=10)
|
||||
# sid_2 stays fresh
|
||||
|
||||
expired = await manager.expire_inactive_sessions(timeout_seconds=300)
|
||||
|
||||
assert len(expired) == 2
|
||||
assert "sid_1" in expired
|
||||
assert "sid_3" in expired
|
||||
assert "sid_2" not in expired
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# CONNECTION STATISTICS TESTS
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class TestConnectionStatistics:
|
||||
"""Tests for connection statistics functionality."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_stats_empty(self):
|
||||
"""
|
||||
Verify get_stats() returns zero counts when no connections.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
stats = manager.get_stats()
|
||||
|
||||
assert stats["total_sessions"] == 0
|
||||
assert stats["unique_users"] == 0
|
||||
assert stats["active_game_rooms"] == 0
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_stats_with_sessions(self):
|
||||
"""
|
||||
Verify get_stats() counts active sessions correctly.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
sio.enter_room = AsyncMock()
|
||||
sio.emit = AsyncMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
await manager.connect("sid_1", "user_1")
|
||||
await manager.connect("sid_2", "user_2")
|
||||
await manager.connect("sid_3", "user_1") # Same user, different session
|
||||
|
||||
stats = manager.get_stats()
|
||||
|
||||
assert stats["total_sessions"] == 3
|
||||
assert stats["unique_users"] == 2 # Only 2 unique users
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_stats_with_games(self):
|
||||
"""
|
||||
Verify get_stats() counts active game rooms.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
sio.enter_room = AsyncMock()
|
||||
sio.emit = AsyncMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
await manager.connect("sid_1", "user_1")
|
||||
await manager.connect("sid_2", "user_2")
|
||||
await manager.join_game("sid_1", "game_A", "home")
|
||||
await manager.join_game("sid_2", "game_A", "away")
|
||||
await manager.join_game("sid_1", "game_B", "home")
|
||||
|
||||
stats = manager.get_stats()
|
||||
|
||||
assert stats["active_game_rooms"] == 2
|
||||
assert "game_A" in stats["sessions_per_game"]
|
||||
assert stats["sessions_per_game"]["game_A"] == 2
|
||||
assert stats["sessions_per_game"]["game_B"] == 1
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_stats_inactivity_distribution(self):
|
||||
"""
|
||||
Verify get_stats() categorizes sessions by inactivity.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
await manager.connect("sid_1", "user_1")
|
||||
await manager.connect("sid_2", "user_2")
|
||||
await manager.connect("sid_3", "user_3")
|
||||
|
||||
# Make sessions have different inactivity levels
|
||||
now = pendulum.now("UTC")
|
||||
manager._sessions["sid_1"].last_activity = now # Active (<1m)
|
||||
manager._sessions["sid_2"].last_activity = now.subtract(minutes=3) # 1-5m
|
||||
manager._sessions["sid_3"].last_activity = now.subtract(minutes=20) # >15m
|
||||
|
||||
stats = manager.get_stats()
|
||||
|
||||
assert stats["inactivity_distribution"]["<1m"] == 1
|
||||
assert stats["inactivity_distribution"]["1-5m"] == 1
|
||||
assert stats["inactivity_distribution"][">15m"] == 1
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_stats_session_ages(self):
|
||||
"""
|
||||
Verify get_stats() calculates session age statistics.
|
||||
"""
|
||||
sio = MagicMock()
|
||||
manager = ConnectionManager(sio)
|
||||
|
||||
now = pendulum.now("UTC")
|
||||
|
||||
await manager.connect("sid_1", "user_1")
|
||||
# Override connected_at to simulate older connection
|
||||
manager._sessions["sid_1"].connected_at = now.subtract(minutes=30)
|
||||
|
||||
await manager.connect("sid_2", "user_2")
|
||||
# Fresh connection
|
||||
|
||||
stats = manager.get_stats()
|
||||
|
||||
# Oldest should be around 30 minutes = 1800 seconds
|
||||
assert stats["oldest_session_seconds"] > 1700
|
||||
|
||||
# Average should be around 15 minutes = 900 seconds
|
||||
assert 800 < stats["avg_session_seconds"] < 1000
|
||||
513
backend/tests/unit/websocket/test_handler_locking.py
Normal file
513
backend/tests/unit/websocket/test_handler_locking.py
Normal file
@ -0,0 +1,513 @@
|
||||
"""
|
||||
Tests for WebSocket handler locking mechanism.
|
||||
|
||||
Verifies that state-modifying handlers properly acquire game locks to prevent
|
||||
race conditions from concurrent operations on the same game.
|
||||
|
||||
These tests validate the fix implemented in MASTER_TRACKER task 002.
|
||||
|
||||
Author: Claude
|
||||
Date: 2025-01-27
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import pytest
|
||||
from contextlib import asynccontextmanager
|
||||
from uuid import uuid4
|
||||
from unittest.mock import AsyncMock, MagicMock, patch
|
||||
|
||||
from tests.unit.websocket.conftest import get_handler
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# ROLL_DICE LOCKING TESTS
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class TestRollDiceLocking:
|
||||
"""Tests for locking behavior in roll_dice handler."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_roll_dice_acquires_lock(
|
||||
self, mock_manager, mock_game_state, mock_ab_roll
|
||||
):
|
||||
"""
|
||||
Verify roll_dice acquires game lock before modifying state.
|
||||
|
||||
The handler should call state_manager.game_lock() as an async context
|
||||
manager before setting state.pending_manual_roll.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
lock_acquired = False
|
||||
lock_game_id = None
|
||||
|
||||
@asynccontextmanager
|
||||
async def tracking_lock(game_id, timeout=30.0):
|
||||
nonlocal lock_acquired, lock_game_id
|
||||
lock_acquired = True
|
||||
lock_game_id = game_id
|
||||
yield
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr, \
|
||||
patch("app.websocket.handlers.dice_system") as mock_dice:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
mock_state_mgr.update_state = MagicMock()
|
||||
mock_state_mgr.game_lock = tracking_lock
|
||||
mock_dice.roll_ab.return_value = mock_ab_roll
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["roll_dice"]
|
||||
|
||||
await handler("test_sid", {"game_id": str(mock_game_state.game_id)})
|
||||
|
||||
assert lock_acquired, "Handler should acquire game lock"
|
||||
assert lock_game_id == mock_game_state.game_id, "Lock should be for correct game"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_roll_dice_releases_lock_on_success(
|
||||
self, mock_manager, mock_game_state, mock_ab_roll
|
||||
):
|
||||
"""
|
||||
Verify roll_dice releases lock after successful operation.
|
||||
|
||||
The lock should be released even after successful state modification
|
||||
to allow subsequent operations.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
lock_released = False
|
||||
|
||||
@asynccontextmanager
|
||||
async def tracking_lock(game_id, timeout=30.0):
|
||||
nonlocal lock_released
|
||||
try:
|
||||
yield
|
||||
finally:
|
||||
lock_released = True
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr, \
|
||||
patch("app.websocket.handlers.dice_system") as mock_dice:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
mock_state_mgr.update_state = MagicMock()
|
||||
mock_state_mgr.game_lock = tracking_lock
|
||||
mock_dice.roll_ab.return_value = mock_ab_roll
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["roll_dice"]
|
||||
|
||||
await handler("test_sid", {"game_id": str(mock_game_state.game_id)})
|
||||
|
||||
assert lock_released, "Lock should be released after success"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_roll_dice_releases_lock_on_error(self, mock_manager, mock_game_state):
|
||||
"""
|
||||
Verify roll_dice releases lock even when an error occurs.
|
||||
|
||||
The lock must be released in the finally block to prevent deadlocks.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
lock_released = False
|
||||
|
||||
@asynccontextmanager
|
||||
async def tracking_lock(game_id, timeout=30.0):
|
||||
nonlocal lock_released
|
||||
try:
|
||||
yield
|
||||
finally:
|
||||
lock_released = True
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr, \
|
||||
patch("app.websocket.handlers.dice_system") as mock_dice:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
mock_state_mgr.update_state = MagicMock()
|
||||
mock_state_mgr.game_lock = tracking_lock
|
||||
# Simulate dice system error
|
||||
mock_dice.roll_ab.side_effect = RuntimeError("Dice error")
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["roll_dice"]
|
||||
|
||||
await handler("test_sid", {"game_id": str(mock_game_state.game_id)})
|
||||
|
||||
assert lock_released, "Lock should be released even on error"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_roll_dice_timeout_returns_error(self, mock_manager):
|
||||
"""
|
||||
Verify roll_dice returns user-friendly error on lock timeout.
|
||||
|
||||
When the lock cannot be acquired within the timeout period, the handler
|
||||
should emit a 'server busy' error message to the user.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
@asynccontextmanager
|
||||
async def timeout_lock(game_id, timeout=30.0):
|
||||
raise asyncio.TimeoutError(f"Lock timeout for game {game_id}")
|
||||
yield # Never reached
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
mock_state_mgr.get_state.return_value = MagicMock(game_id=uuid4(), league_id="sba")
|
||||
mock_state_mgr.game_lock = timeout_lock
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["roll_dice"]
|
||||
|
||||
await handler("test_sid", {"game_id": str(uuid4())})
|
||||
|
||||
mock_manager.emit_to_user.assert_called_once()
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "error"
|
||||
assert "busy" in call_args[0][2]["message"].lower()
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# SUBMIT_MANUAL_OUTCOME LOCKING TESTS
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class TestSubmitOutcomeLocking:
|
||||
"""Tests for locking behavior in submit_manual_outcome handler."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_submit_outcome_acquires_lock(
|
||||
self, mock_manager, mock_game_state, mock_ab_roll, mock_play_result
|
||||
):
|
||||
"""
|
||||
Verify submit_manual_outcome acquires lock before processing.
|
||||
|
||||
The lock must be acquired before checking/clearing pending_manual_roll
|
||||
to prevent race conditions with concurrent submissions.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
lock_acquired = False
|
||||
mock_game_state.pending_manual_roll = mock_ab_roll
|
||||
|
||||
@asynccontextmanager
|
||||
async def tracking_lock(game_id, timeout=30.0):
|
||||
nonlocal lock_acquired
|
||||
lock_acquired = True
|
||||
yield
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr, \
|
||||
patch("app.websocket.handlers.game_engine") as mock_engine:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
mock_state_mgr.update_state = MagicMock()
|
||||
mock_state_mgr.game_lock = tracking_lock
|
||||
mock_engine.resolve_manual_play = AsyncMock(return_value=mock_play_result)
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["submit_manual_outcome"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(mock_game_state.game_id),
|
||||
"outcome": "groundball_c",
|
||||
"hit_location": "SS",
|
||||
},
|
||||
)
|
||||
|
||||
assert lock_acquired, "Handler should acquire game lock"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_submit_outcome_timeout_returns_error(self, mock_manager):
|
||||
"""
|
||||
Verify submit_manual_outcome returns error on lock timeout.
|
||||
|
||||
Same as roll_dice - should emit 'server busy' message.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
@asynccontextmanager
|
||||
async def timeout_lock(game_id, timeout=30.0):
|
||||
raise asyncio.TimeoutError(f"Lock timeout for game {game_id}")
|
||||
yield
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
mock_game_state = MagicMock()
|
||||
mock_game_state.game_id = uuid4()
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
mock_state_mgr.game_lock = timeout_lock
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["submit_manual_outcome"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(uuid4()),
|
||||
"outcome": "groundball_c",
|
||||
},
|
||||
)
|
||||
|
||||
mock_manager.emit_to_user.assert_called_once()
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "error"
|
||||
assert "busy" in call_args[0][2]["message"].lower()
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# SUBSTITUTION HANDLER LOCKING TESTS
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class TestSubstitutionHandlerLocking:
|
||||
"""Tests for locking behavior in substitution handlers."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_pinch_hitter_acquires_lock(
|
||||
self, mock_manager, mock_game_state, mock_substitution_result_success
|
||||
):
|
||||
"""
|
||||
Verify request_pinch_hitter acquires lock before substitution.
|
||||
|
||||
Substitutions must be serialized to prevent duplicate substitution
|
||||
requests corrupting lineup state.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
lock_acquired = False
|
||||
|
||||
@asynccontextmanager
|
||||
async def tracking_lock(game_id, timeout=30.0):
|
||||
nonlocal lock_acquired
|
||||
lock_acquired = True
|
||||
yield
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr, \
|
||||
patch("app.websocket.handlers.SubstitutionManager") as MockSubMgr:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
mock_state_mgr.game_lock = tracking_lock
|
||||
|
||||
mock_sub_instance = MagicMock()
|
||||
mock_sub_instance.pinch_hit = AsyncMock(
|
||||
return_value=mock_substitution_result_success
|
||||
)
|
||||
MockSubMgr.return_value = mock_sub_instance
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_pinch_hitter"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(mock_game_state.game_id),
|
||||
"player_out_lineup_id": 1,
|
||||
"player_in_card_id": 999,
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
assert lock_acquired, "Pinch hitter should acquire game lock"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_defensive_replacement_acquires_lock(
|
||||
self, mock_manager, mock_game_state, mock_substitution_result_success
|
||||
):
|
||||
"""Verify request_defensive_replacement acquires lock."""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
lock_acquired = False
|
||||
|
||||
@asynccontextmanager
|
||||
async def tracking_lock(game_id, timeout=30.0):
|
||||
nonlocal lock_acquired
|
||||
lock_acquired = True
|
||||
yield
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr, \
|
||||
patch("app.websocket.handlers.SubstitutionManager") as MockSubMgr:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
mock_state_mgr.game_lock = tracking_lock
|
||||
|
||||
mock_sub_instance = MagicMock()
|
||||
mock_sub_instance.defensive_replace = AsyncMock(
|
||||
return_value=mock_substitution_result_success
|
||||
)
|
||||
MockSubMgr.return_value = mock_sub_instance
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_defensive_replacement"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(mock_game_state.game_id),
|
||||
"player_out_lineup_id": 1,
|
||||
"player_in_card_id": 999,
|
||||
"new_position": "CF",
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
assert lock_acquired, "Defensive replacement should acquire game lock"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_pitching_change_acquires_lock(
|
||||
self, mock_manager, mock_game_state, mock_substitution_result_success
|
||||
):
|
||||
"""Verify request_pitching_change acquires lock."""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
lock_acquired = False
|
||||
|
||||
@asynccontextmanager
|
||||
async def tracking_lock(game_id, timeout=30.0):
|
||||
nonlocal lock_acquired
|
||||
lock_acquired = True
|
||||
yield
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr, \
|
||||
patch("app.websocket.handlers.SubstitutionManager") as MockSubMgr:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
mock_state_mgr.game_lock = tracking_lock
|
||||
|
||||
mock_sub_instance = MagicMock()
|
||||
mock_sub_instance.change_pitcher = AsyncMock(
|
||||
return_value=mock_substitution_result_success
|
||||
)
|
||||
MockSubMgr.return_value = mock_sub_instance
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_pitching_change"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(mock_game_state.game_id),
|
||||
"player_out_lineup_id": 1,
|
||||
"player_in_card_id": 999,
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
assert lock_acquired, "Pitching change should acquire game lock"
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# CONCURRENT ACCESS TESTS
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class TestConcurrentAccess:
|
||||
"""Tests for behavior under concurrent access scenarios."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_different_games_do_not_block(self, mock_manager, mock_ab_roll):
|
||||
"""
|
||||
Verify that handlers for different games do not block each other.
|
||||
|
||||
Operations on game_1 should not wait for operations on game_2.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
game_1_id = uuid4()
|
||||
game_2_id = uuid4()
|
||||
locks_acquired = {game_1_id: False, game_2_id: False}
|
||||
|
||||
@asynccontextmanager
|
||||
async def tracking_lock(game_id, timeout=30.0):
|
||||
locks_acquired[game_id] = True
|
||||
yield
|
||||
|
||||
mock_state_1 = MagicMock(game_id=game_1_id, league_id="sba")
|
||||
mock_state_2 = MagicMock(game_id=game_2_id, league_id="sba")
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr, \
|
||||
patch("app.websocket.handlers.dice_system") as mock_dice:
|
||||
|
||||
def get_state(gid):
|
||||
if gid == game_1_id:
|
||||
return mock_state_1
|
||||
elif gid == game_2_id:
|
||||
return mock_state_2
|
||||
return None
|
||||
|
||||
mock_state_mgr.get_state.side_effect = get_state
|
||||
mock_state_mgr.update_state = MagicMock()
|
||||
mock_state_mgr.game_lock = tracking_lock
|
||||
mock_dice.roll_ab.return_value = mock_ab_roll
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["roll_dice"]
|
||||
|
||||
# Call handlers for both games
|
||||
await handler("sid_1", {"game_id": str(game_1_id)})
|
||||
await handler("sid_2", {"game_id": str(game_2_id)})
|
||||
|
||||
# Both should have acquired their own locks
|
||||
assert locks_acquired[game_1_id], "Game 1 should acquire its lock"
|
||||
assert locks_acquired[game_2_id], "Game 2 should acquire its lock"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_lock_timeout_is_30_seconds(self, mock_manager, mock_game_state):
|
||||
"""
|
||||
Verify that the default lock timeout is 30 seconds.
|
||||
|
||||
The game_lock context manager should be called with timeout=30.0.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
timeout_used = None
|
||||
|
||||
@asynccontextmanager
|
||||
async def tracking_lock(game_id, timeout=30.0):
|
||||
nonlocal timeout_used
|
||||
timeout_used = timeout
|
||||
yield
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr, \
|
||||
patch("app.websocket.handlers.dice_system") as mock_dice:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
mock_state_mgr.update_state = MagicMock()
|
||||
mock_state_mgr.game_lock = tracking_lock
|
||||
mock_dice.roll_ab.return_value = MagicMock()
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["roll_dice"]
|
||||
|
||||
await handler("test_sid", {"game_id": str(mock_game_state.game_id)})
|
||||
|
||||
# The lock uses default timeout, which should be 30.0
|
||||
# Note: If timeout is not explicitly passed, it uses the default
|
||||
assert timeout_used == 30.0, f"Expected 30.0s timeout, got {timeout_used}"
|
||||
@ -30,6 +30,7 @@ def mock_manager():
|
||||
manager = MagicMock()
|
||||
manager.emit_to_user = AsyncMock()
|
||||
manager.broadcast_to_game = AsyncMock()
|
||||
manager.update_activity = AsyncMock()
|
||||
return manager
|
||||
|
||||
|
||||
|
||||
444
backend/tests/unit/websocket/test_query_handlers.py
Normal file
444
backend/tests/unit/websocket/test_query_handlers.py
Normal file
@ -0,0 +1,444 @@
|
||||
"""
|
||||
Tests for WebSocket query and decision handlers.
|
||||
|
||||
Verifies lineup retrieval (get_lineup), box score (get_box_score),
|
||||
and strategic decision submission handlers (submit_defensive_decision,
|
||||
submit_offensive_decision).
|
||||
|
||||
Author: Claude
|
||||
Date: 2025-01-27
|
||||
"""
|
||||
|
||||
import pytest
|
||||
from uuid import uuid4
|
||||
from unittest.mock import AsyncMock, MagicMock, patch
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# GET LINEUP HANDLER TESTS
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class TestGetLineupHandler:
|
||||
"""Tests for the get_lineup event handler."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_lineup_from_cache(self, mock_manager, mock_lineup_state):
|
||||
"""
|
||||
Verify get_lineup() returns cached lineup when available.
|
||||
|
||||
StateManager caches lineups for fast O(1) lookup. When lineup is
|
||||
in cache, handler should return it without hitting database.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
game_id = uuid4()
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
mock_state_mgr.get_lineup.return_value = mock_lineup_state
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["get_lineup"]
|
||||
|
||||
await handler("test_sid", {"game_id": str(game_id), "team_id": 1})
|
||||
|
||||
mock_state_mgr.get_lineup.assert_called_once_with(game_id, 1)
|
||||
mock_manager.emit_to_user.assert_called_once()
|
||||
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "lineup_data"
|
||||
assert call_args[0][2]["team_id"] == 1
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_lineup_from_db_when_not_cached(
|
||||
self, mock_manager, mock_lineup_state, mock_game_state
|
||||
):
|
||||
"""
|
||||
Verify get_lineup() loads from database when not in cache.
|
||||
|
||||
When lineup is not cached, handler should load from database
|
||||
via lineup_service and cache the result.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
game_id = uuid4()
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr, \
|
||||
patch("app.websocket.handlers.lineup_service") as mock_lineup_svc:
|
||||
mock_state_mgr.get_lineup.return_value = None # Not cached
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
mock_lineup_svc.load_team_lineup_with_player_data = AsyncMock(
|
||||
return_value=mock_lineup_state
|
||||
)
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["get_lineup"]
|
||||
|
||||
await handler("test_sid", {"game_id": str(game_id), "team_id": 1})
|
||||
|
||||
mock_lineup_svc.load_team_lineup_with_player_data.assert_called_once()
|
||||
mock_state_mgr.set_lineup.assert_called_once() # Cache it
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_lineup_missing_game_id(self, mock_manager):
|
||||
"""
|
||||
Verify get_lineup() returns error when game_id missing.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["get_lineup"]
|
||||
|
||||
await handler("test_sid", {"team_id": 1})
|
||||
|
||||
mock_manager.emit_to_user.assert_called_once()
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "error"
|
||||
assert "game_id" in call_args[0][2]["message"].lower()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_lineup_missing_team_id(self, mock_manager):
|
||||
"""
|
||||
Verify get_lineup() returns error when team_id missing.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["get_lineup"]
|
||||
|
||||
await handler("test_sid", {"game_id": str(uuid4())})
|
||||
|
||||
mock_manager.emit_to_user.assert_called_once()
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "error"
|
||||
assert "team_id" in call_args[0][2]["message"].lower()
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# GET BOX SCORE HANDLER TESTS
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class TestGetBoxScoreHandler:
|
||||
"""Tests for the get_box_score event handler."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_box_score_success(self, mock_manager):
|
||||
"""
|
||||
Verify get_box_score() returns box score data from service.
|
||||
|
||||
Handler should fetch box score from materialized views via
|
||||
box_score_service and emit to requester.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
game_id = uuid4()
|
||||
mock_box_score = {
|
||||
"home_team": {"runs": 5, "hits": 10, "errors": 1},
|
||||
"away_team": {"runs": 3, "hits": 7, "errors": 2},
|
||||
}
|
||||
|
||||
# box_score_service is imported inside the handler via:
|
||||
# from app.services import box_score_service
|
||||
with patch("app.services.box_score_service") as mock_service:
|
||||
mock_service.get_box_score = AsyncMock(return_value=mock_box_score)
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["get_box_score"]
|
||||
|
||||
await handler("test_sid", {"game_id": str(game_id)})
|
||||
|
||||
mock_service.get_box_score.assert_called_once_with(game_id)
|
||||
mock_manager.emit_to_user.assert_called_once()
|
||||
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "box_score_data"
|
||||
assert call_args[0][2]["box_score"] == mock_box_score
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_box_score_not_found(self, mock_manager):
|
||||
"""
|
||||
Verify get_box_score() returns error when no data found.
|
||||
|
||||
When materialized views return no data (e.g., game hasn't started),
|
||||
handler should emit error with helpful hint about migrations.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
# box_score_service is imported inside the handler
|
||||
with patch("app.services.box_score_service") as mock_service:
|
||||
mock_service.get_box_score = AsyncMock(return_value=None)
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["get_box_score"]
|
||||
|
||||
await handler("test_sid", {"game_id": str(uuid4())})
|
||||
|
||||
mock_manager.emit_to_user.assert_called_once()
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "error"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_box_score_missing_game_id(self, mock_manager):
|
||||
"""
|
||||
Verify get_box_score() returns error when game_id missing.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["get_box_score"]
|
||||
|
||||
await handler("test_sid", {})
|
||||
|
||||
mock_manager.emit_to_user.assert_called_once()
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "error"
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# SUBMIT DEFENSIVE DECISION HANDLER TESTS
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class TestSubmitDefensiveDecisionHandler:
|
||||
"""Tests for the submit_defensive_decision event handler."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_submit_defensive_decision_success(
|
||||
self, mock_manager, mock_game_state
|
||||
):
|
||||
"""
|
||||
Verify submit_defensive_decision() processes and broadcasts decision.
|
||||
|
||||
Handler should create DefensiveDecision, submit to game engine,
|
||||
and broadcast to game room so both teams see the defense strategy.
|
||||
|
||||
Valid values:
|
||||
- infield_depth: infield_in, normal, corners_in
|
||||
- outfield_depth: normal, shallow
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr, \
|
||||
patch("app.websocket.handlers.game_engine") as mock_engine:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
updated_state = MagicMock()
|
||||
updated_state.pending_decision = None
|
||||
mock_engine.submit_defensive_decision = AsyncMock(return_value=updated_state)
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["submit_defensive_decision"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(mock_game_state.game_id),
|
||||
"infield_depth": "infield_in", # Valid: infield_in, normal, corners_in
|
||||
"outfield_depth": "shallow", # Valid: normal, shallow
|
||||
"hold_runners": [1],
|
||||
},
|
||||
)
|
||||
|
||||
mock_engine.submit_defensive_decision.assert_called_once()
|
||||
mock_manager.broadcast_to_game.assert_called_once()
|
||||
|
||||
call_args = mock_manager.broadcast_to_game.call_args
|
||||
assert call_args[0][1] == "defensive_decision_submitted"
|
||||
assert call_args[0][2]["decision"]["infield_depth"] == "infield_in"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_submit_defensive_decision_uses_defaults(
|
||||
self, mock_manager, mock_game_state
|
||||
):
|
||||
"""
|
||||
Verify submit_defensive_decision() uses default values when not provided.
|
||||
|
||||
Handler should default to normal alignment, normal depth, no hold runners
|
||||
when these fields are omitted from the request.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr, \
|
||||
patch("app.websocket.handlers.game_engine") as mock_engine:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
updated_state = MagicMock()
|
||||
updated_state.pending_decision = None
|
||||
mock_engine.submit_defensive_decision = AsyncMock(return_value=updated_state)
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["submit_defensive_decision"]
|
||||
|
||||
await handler("test_sid", {"game_id": str(mock_game_state.game_id)})
|
||||
|
||||
call_args = mock_manager.broadcast_to_game.call_args
|
||||
decision = call_args[0][2]["decision"]
|
||||
assert decision["alignment"] == "normal"
|
||||
assert decision["infield_depth"] == "normal"
|
||||
assert decision["outfield_depth"] == "normal"
|
||||
assert decision["hold_runners"] == []
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_submit_defensive_decision_game_not_found(self, mock_manager):
|
||||
"""
|
||||
Verify submit_defensive_decision() returns error when game not found.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
mock_state_mgr.get_state.return_value = None
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["submit_defensive_decision"]
|
||||
|
||||
await handler("test_sid", {"game_id": str(uuid4())})
|
||||
|
||||
mock_manager.emit_to_user.assert_called_once()
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "error"
|
||||
assert "not found" in call_args[0][2]["message"].lower()
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# SUBMIT OFFENSIVE DECISION HANDLER TESTS
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class TestSubmitOffensiveDecisionHandler:
|
||||
"""Tests for the submit_offensive_decision event handler."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_submit_offensive_decision_success(
|
||||
self, mock_manager, mock_game_state
|
||||
):
|
||||
"""
|
||||
Verify submit_offensive_decision() processes and broadcasts decision.
|
||||
|
||||
Handler should create OffensiveDecision with action and steal attempts,
|
||||
submit to game engine, and broadcast to game room.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr, \
|
||||
patch("app.websocket.handlers.game_engine") as mock_engine:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
updated_state = MagicMock()
|
||||
updated_state.pending_decision = None
|
||||
mock_engine.submit_offensive_decision = AsyncMock(return_value=updated_state)
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["submit_offensive_decision"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(mock_game_state.game_id),
|
||||
"action": "steal",
|
||||
"steal_attempts": [2],
|
||||
},
|
||||
)
|
||||
|
||||
mock_engine.submit_offensive_decision.assert_called_once()
|
||||
mock_manager.broadcast_to_game.assert_called_once()
|
||||
|
||||
call_args = mock_manager.broadcast_to_game.call_args
|
||||
assert call_args[0][1] == "offensive_decision_submitted"
|
||||
assert call_args[0][2]["decision"]["action"] == "steal"
|
||||
assert call_args[0][2]["decision"]["steal_attempts"] == [2]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_submit_offensive_decision_defaults_to_swing_away(
|
||||
self, mock_manager, mock_game_state
|
||||
):
|
||||
"""
|
||||
Verify submit_offensive_decision() defaults to swing_away action.
|
||||
|
||||
When no action is provided, handler should default to swing_away
|
||||
which is the most common offensive approach.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr, \
|
||||
patch("app.websocket.handlers.game_engine") as mock_engine:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
updated_state = MagicMock()
|
||||
updated_state.pending_decision = None
|
||||
mock_engine.submit_offensive_decision = AsyncMock(return_value=updated_state)
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["submit_offensive_decision"]
|
||||
|
||||
await handler("test_sid", {"game_id": str(mock_game_state.game_id)})
|
||||
|
||||
call_args = mock_manager.broadcast_to_game.call_args
|
||||
decision = call_args[0][2]["decision"]
|
||||
assert decision["action"] == "swing_away"
|
||||
assert decision["steal_attempts"] == []
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_submit_offensive_decision_game_not_found(self, mock_manager):
|
||||
"""
|
||||
Verify submit_offensive_decision() returns error when game not found.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
mock_state_mgr.get_state.return_value = None
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["submit_offensive_decision"]
|
||||
|
||||
await handler("test_sid", {"game_id": str(uuid4())})
|
||||
|
||||
mock_manager.emit_to_user.assert_called_once()
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "error"
|
||||
assert "not found" in call_args[0][2]["message"].lower()
|
||||
710
backend/tests/unit/websocket/test_rate_limiting.py
Normal file
710
backend/tests/unit/websocket/test_rate_limiting.py
Normal file
@ -0,0 +1,710 @@
|
||||
"""
|
||||
Tests for rate limiting in WebSocket handlers.
|
||||
|
||||
Verifies that rate limiting is properly applied at both connection and
|
||||
game levels for all handlers that implement rate limiting. This is critical
|
||||
for DOS protection.
|
||||
|
||||
Author: Claude
|
||||
Date: 2025-11-27
|
||||
"""
|
||||
|
||||
import pytest
|
||||
from uuid import uuid4
|
||||
from unittest.mock import AsyncMock, MagicMock, patch
|
||||
from contextlib import asynccontextmanager
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# CONNECTION-LEVEL RATE LIMITING TESTS
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class TestConnectionRateLimiting:
|
||||
"""
|
||||
Tests for connection-level rate limiting across handlers.
|
||||
|
||||
Connection-level rate limiting prevents any single connection from
|
||||
overwhelming the server with requests, regardless of the request type.
|
||||
"""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_join_game_rate_limited_returns_error(self, mock_manager):
|
||||
"""
|
||||
Verify join_game returns error when connection is rate limited.
|
||||
|
||||
When a connection exceeds its rate limit, the handler should emit
|
||||
an error with code RATE_LIMITED and not process the join request.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.rate_limiter") as mock_limiter:
|
||||
mock_limiter.check_websocket_limit = AsyncMock(return_value=False)
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["join_game"]
|
||||
|
||||
await handler("test_sid", {"game_id": str(uuid4())})
|
||||
|
||||
# Verify error emitted
|
||||
mock_manager.emit_to_user.assert_called_once()
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "error"
|
||||
assert "RATE_LIMITED" in call_args[0][2]["code"]
|
||||
|
||||
# Verify join not attempted
|
||||
mock_manager.join_game.assert_not_called()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_request_game_state_rate_limited(self, mock_manager):
|
||||
"""
|
||||
Verify request_game_state returns error when rate limited.
|
||||
|
||||
Game state requests can be expensive (database recovery), so rate
|
||||
limiting is essential to prevent abuse.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.rate_limiter") as mock_limiter:
|
||||
mock_limiter.check_websocket_limit = AsyncMock(return_value=False)
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_game_state"]
|
||||
|
||||
await handler("test_sid", {"game_id": str(uuid4())})
|
||||
|
||||
# Verify rate limit error
|
||||
mock_manager.emit_to_user.assert_called_once()
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "error"
|
||||
assert "RATE_LIMITED" in call_args[0][2]["code"]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_roll_dice_rate_limited_at_connection_level(self, mock_manager):
|
||||
"""
|
||||
Verify roll_dice checks connection-level rate limit first.
|
||||
|
||||
Roll dice has both connection-level and game-level limits. The
|
||||
connection limit is checked first.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.rate_limiter") as mock_limiter:
|
||||
mock_limiter.check_websocket_limit = AsyncMock(return_value=False)
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["roll_dice"]
|
||||
|
||||
await handler("test_sid", {"game_id": str(uuid4())})
|
||||
|
||||
mock_manager.emit_to_user.assert_called_once()
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "error"
|
||||
assert "RATE_LIMITED" in call_args[0][2]["code"]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_submit_manual_outcome_rate_limited(self, mock_manager):
|
||||
"""
|
||||
Verify submit_manual_outcome returns error when rate limited.
|
||||
|
||||
Manual outcome submissions must be rate limited to prevent flooding.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.rate_limiter") as mock_limiter:
|
||||
mock_limiter.check_websocket_limit = AsyncMock(return_value=False)
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["submit_manual_outcome"]
|
||||
|
||||
await handler("test_sid", {"game_id": str(uuid4()), "outcome": "single"})
|
||||
|
||||
mock_manager.emit_to_user.assert_called_once()
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "error"
|
||||
assert "RATE_LIMITED" in call_args[0][2]["code"]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_lineup_rate_limited(self, mock_manager):
|
||||
"""
|
||||
Verify get_lineup returns error when rate limited.
|
||||
|
||||
Lineup queries can hit the database, so rate limiting prevents abuse.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.rate_limiter") as mock_limiter:
|
||||
mock_limiter.check_websocket_limit = AsyncMock(return_value=False)
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["get_lineup"]
|
||||
|
||||
await handler("test_sid", {"game_id": str(uuid4()), "team_id": 1})
|
||||
|
||||
mock_manager.emit_to_user.assert_called_once()
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "error"
|
||||
assert "RATE_LIMITED" in call_args[0][2]["code"]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_box_score_rate_limited(self, mock_manager):
|
||||
"""
|
||||
Verify get_box_score returns error when rate limited.
|
||||
|
||||
Box score queries aggregate data, so they're expensive and need limiting.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.rate_limiter") as mock_limiter:
|
||||
mock_limiter.check_websocket_limit = AsyncMock(return_value=False)
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["get_box_score"]
|
||||
|
||||
await handler("test_sid", {"game_id": str(uuid4())})
|
||||
|
||||
mock_manager.emit_to_user.assert_called_once()
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "error"
|
||||
assert "RATE_LIMITED" in call_args[0][2]["code"]
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# GAME-LEVEL RATE LIMITING TESTS
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class TestGameRateLimiting:
|
||||
"""
|
||||
Tests for game-level rate limiting.
|
||||
|
||||
Game-level rate limiting prevents any single game from being flooded
|
||||
with actions, protecting the game state integrity and server resources.
|
||||
"""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_roll_dice_game_rate_limited(self, mock_manager, mock_game_state):
|
||||
"""
|
||||
Verify roll_dice returns error when game roll limit exceeded.
|
||||
|
||||
Dice rolls have a per-game limit to prevent spamming. When the limit
|
||||
is exceeded, the handler should emit a GAME_RATE_LIMITED error.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
@asynccontextmanager
|
||||
async def mock_lock(game_id, timeout=30.0):
|
||||
yield
|
||||
|
||||
with patch("app.websocket.handlers.rate_limiter") as mock_limiter, \
|
||||
patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
# Connection limit passes, game limit fails
|
||||
mock_limiter.check_websocket_limit = AsyncMock(return_value=True)
|
||||
mock_limiter.check_game_limit = AsyncMock(return_value=False)
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
mock_state_mgr.game_lock = mock_lock
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["roll_dice"]
|
||||
|
||||
await handler("test_sid", {"game_id": str(mock_game_state.game_id)})
|
||||
|
||||
# Verify game rate limit error
|
||||
mock_manager.emit_to_user.assert_called()
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "error"
|
||||
assert "GAME_RATE_LIMITED" in call_args[0][2]["code"]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_submit_manual_outcome_game_rate_limited(
|
||||
self, mock_manager, mock_game_state
|
||||
):
|
||||
"""
|
||||
Verify submit_manual_outcome returns error when game decision limit exceeded.
|
||||
|
||||
Decision submissions have per-game limits to prevent rapid-fire outcomes.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.rate_limiter") as mock_limiter, \
|
||||
patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
mock_limiter.check_websocket_limit = AsyncMock(return_value=True)
|
||||
mock_limiter.check_game_limit = AsyncMock(return_value=False)
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["submit_manual_outcome"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{"game_id": str(mock_game_state.game_id), "outcome": "single"},
|
||||
)
|
||||
|
||||
mock_manager.emit_to_user.assert_called()
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "error"
|
||||
assert "GAME_RATE_LIMITED" in call_args[0][2]["code"]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_submit_defensive_decision_game_rate_limited(
|
||||
self, mock_manager, mock_game_state
|
||||
):
|
||||
"""
|
||||
Verify submit_defensive_decision returns error when game decision limit exceeded.
|
||||
|
||||
Defensive decisions use the 'decision' action type for rate limiting.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.rate_limiter") as mock_limiter, \
|
||||
patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
mock_limiter.check_websocket_limit = AsyncMock(return_value=True)
|
||||
mock_limiter.check_game_limit = AsyncMock(return_value=False)
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["submit_defensive_decision"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{"game_id": str(mock_game_state.game_id), "alignment": "normal"},
|
||||
)
|
||||
|
||||
mock_manager.emit_to_user.assert_called()
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "error"
|
||||
assert "GAME_RATE_LIMITED" in call_args[0][2]["code"]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_submit_offensive_decision_game_rate_limited(
|
||||
self, mock_manager, mock_game_state
|
||||
):
|
||||
"""
|
||||
Verify submit_offensive_decision returns error when game decision limit exceeded.
|
||||
|
||||
Offensive decisions use the 'decision' action type for rate limiting.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.rate_limiter") as mock_limiter, \
|
||||
patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
mock_limiter.check_websocket_limit = AsyncMock(return_value=True)
|
||||
mock_limiter.check_game_limit = AsyncMock(return_value=False)
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["submit_offensive_decision"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{"game_id": str(mock_game_state.game_id), "action": "swing_away"},
|
||||
)
|
||||
|
||||
mock_manager.emit_to_user.assert_called()
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "error"
|
||||
assert "GAME_RATE_LIMITED" in call_args[0][2]["code"]
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# SUBSTITUTION RATE LIMITING TESTS
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class TestSubstitutionRateLimiting:
|
||||
"""
|
||||
Tests for rate limiting on substitution handlers.
|
||||
|
||||
Substitution actions have their own rate limit category to prevent
|
||||
rapid lineup changes which could cause state inconsistencies.
|
||||
"""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_pinch_hitter_connection_rate_limited(self, mock_manager):
|
||||
"""
|
||||
Verify pinch_hitter returns error when connection rate limited.
|
||||
|
||||
Connection-level limits are checked before game-level limits.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.rate_limiter") as mock_limiter:
|
||||
mock_limiter.check_websocket_limit = AsyncMock(return_value=False)
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_pinch_hitter"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(uuid4()),
|
||||
"player_out_lineup_id": 1,
|
||||
"player_in_card_id": 999,
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
mock_manager.emit_to_user.assert_called_once()
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "error"
|
||||
assert "RATE_LIMITED" in call_args[0][2]["code"]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_pinch_hitter_game_rate_limited(self, mock_manager, mock_game_state):
|
||||
"""
|
||||
Verify pinch_hitter returns error when substitution limit exceeded.
|
||||
|
||||
The substitution rate limit is per-game to prevent lineup abuse.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.rate_limiter") as mock_limiter, \
|
||||
patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
mock_limiter.check_websocket_limit = AsyncMock(return_value=True)
|
||||
mock_limiter.check_game_limit = AsyncMock(return_value=False)
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_pinch_hitter"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(mock_game_state.game_id),
|
||||
"player_out_lineup_id": 1,
|
||||
"player_in_card_id": 999,
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
mock_manager.emit_to_user.assert_called()
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "error"
|
||||
assert "GAME_RATE_LIMITED" in call_args[0][2]["code"]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_defensive_replacement_connection_rate_limited(self, mock_manager):
|
||||
"""
|
||||
Verify defensive_replacement returns error when connection rate limited.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.rate_limiter") as mock_limiter:
|
||||
mock_limiter.check_websocket_limit = AsyncMock(return_value=False)
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_defensive_replacement"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(uuid4()),
|
||||
"player_out_lineup_id": 1,
|
||||
"player_in_card_id": 999,
|
||||
"new_position": "CF",
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
mock_manager.emit_to_user.assert_called_once()
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "error"
|
||||
assert "RATE_LIMITED" in call_args[0][2]["code"]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_defensive_replacement_game_rate_limited(
|
||||
self, mock_manager, mock_game_state
|
||||
):
|
||||
"""
|
||||
Verify defensive_replacement returns error when substitution limit exceeded.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.rate_limiter") as mock_limiter, \
|
||||
patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
mock_limiter.check_websocket_limit = AsyncMock(return_value=True)
|
||||
mock_limiter.check_game_limit = AsyncMock(return_value=False)
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_defensive_replacement"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(mock_game_state.game_id),
|
||||
"player_out_lineup_id": 1,
|
||||
"player_in_card_id": 999,
|
||||
"new_position": "CF",
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
mock_manager.emit_to_user.assert_called()
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "error"
|
||||
assert "GAME_RATE_LIMITED" in call_args[0][2]["code"]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_pitching_change_connection_rate_limited(self, mock_manager):
|
||||
"""
|
||||
Verify pitching_change returns error when connection rate limited.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.rate_limiter") as mock_limiter:
|
||||
mock_limiter.check_websocket_limit = AsyncMock(return_value=False)
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_pitching_change"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(uuid4()),
|
||||
"player_out_lineup_id": 1,
|
||||
"player_in_card_id": 999,
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
mock_manager.emit_to_user.assert_called_once()
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "error"
|
||||
assert "RATE_LIMITED" in call_args[0][2]["code"]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_pitching_change_game_rate_limited(
|
||||
self, mock_manager, mock_game_state
|
||||
):
|
||||
"""
|
||||
Verify pitching_change returns error when substitution limit exceeded.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.rate_limiter") as mock_limiter, \
|
||||
patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
mock_limiter.check_websocket_limit = AsyncMock(return_value=True)
|
||||
mock_limiter.check_game_limit = AsyncMock(return_value=False)
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_pitching_change"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(mock_game_state.game_id),
|
||||
"player_out_lineup_id": 1,
|
||||
"player_in_card_id": 999,
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
mock_manager.emit_to_user.assert_called()
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "error"
|
||||
assert "GAME_RATE_LIMITED" in call_args[0][2]["code"]
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# RATE LIMITER CLEANUP TESTS
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class TestRateLimiterCleanup:
|
||||
"""
|
||||
Tests for rate limiter cleanup during disconnect.
|
||||
|
||||
When a connection closes, its rate limiter buckets should be cleaned up
|
||||
to prevent memory leaks.
|
||||
"""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_disconnect_removes_rate_limiter_bucket(self, mock_manager):
|
||||
"""
|
||||
Verify disconnect removes connection's rate limiter bucket.
|
||||
|
||||
When a client disconnects, the rate limiter should clean up the
|
||||
bucket for that connection to prevent memory leaks.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.rate_limiter") as mock_limiter:
|
||||
mock_limiter.remove_connection = MagicMock()
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["disconnect"]
|
||||
|
||||
await handler("test_sid")
|
||||
|
||||
# Verify rate limiter cleanup called
|
||||
mock_limiter.remove_connection.assert_called_once_with("test_sid")
|
||||
# Verify manager disconnect also called
|
||||
mock_manager.disconnect.assert_called_once_with("test_sid")
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_disconnect_cleanup_happens_before_manager(self, mock_manager):
|
||||
"""
|
||||
Verify rate limiter cleanup happens during disconnect.
|
||||
|
||||
The rate limiter bucket removal should happen regardless of
|
||||
other disconnect processing.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
cleanup_order = []
|
||||
|
||||
def track_limiter_cleanup(sid):
|
||||
cleanup_order.append(("limiter", sid))
|
||||
|
||||
async def track_manager_disconnect(sid):
|
||||
cleanup_order.append(("manager", sid))
|
||||
|
||||
with patch("app.websocket.handlers.rate_limiter") as mock_limiter:
|
||||
mock_limiter.remove_connection = track_limiter_cleanup
|
||||
mock_manager.disconnect = track_manager_disconnect
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["disconnect"]
|
||||
|
||||
await handler("test_sid")
|
||||
|
||||
# Both cleanup steps should have happened
|
||||
assert ("limiter", "test_sid") in cleanup_order
|
||||
assert ("manager", "test_sid") in cleanup_order
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# RATE LIMITING ALLOWS WHEN UNDER LIMIT
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class TestRateLimitingAllows:
|
||||
"""
|
||||
Tests verifying that rate limiting allows requests when under limit.
|
||||
|
||||
These tests ensure the rate limiter doesn't accidentally block
|
||||
legitimate requests.
|
||||
"""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_join_game_allowed_when_under_limit(self, mock_manager):
|
||||
"""
|
||||
Verify join_game proceeds normally when rate limit not exceeded.
|
||||
|
||||
The handler should process the request and emit game_joined when
|
||||
the connection is under its rate limit.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.rate_limiter") as mock_limiter:
|
||||
mock_limiter.check_websocket_limit = AsyncMock(return_value=True)
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["join_game"]
|
||||
|
||||
game_id = str(uuid4())
|
||||
await handler("test_sid", {"game_id": game_id})
|
||||
|
||||
# Should proceed with join
|
||||
mock_manager.join_game.assert_called_once()
|
||||
mock_manager.emit_to_user.assert_called_once()
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "game_joined"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_roll_dice_allowed_when_under_limits(
|
||||
self, mock_manager, mock_game_state, mock_ab_roll
|
||||
):
|
||||
"""
|
||||
Verify roll_dice proceeds when both connection and game limits allow.
|
||||
|
||||
Both rate limit checks must pass for the handler to process the roll.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
@asynccontextmanager
|
||||
async def mock_lock(game_id, timeout=30.0):
|
||||
yield
|
||||
|
||||
with patch("app.websocket.handlers.rate_limiter") as mock_limiter, \
|
||||
patch("app.websocket.handlers.state_manager") as mock_state_mgr, \
|
||||
patch("app.websocket.handlers.dice_system") as mock_dice:
|
||||
mock_limiter.check_websocket_limit = AsyncMock(return_value=True)
|
||||
mock_limiter.check_game_limit = AsyncMock(return_value=True)
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
mock_state_mgr.game_lock = mock_lock
|
||||
mock_state_mgr.update_state = MagicMock()
|
||||
mock_dice.roll_ab.return_value = mock_ab_roll
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["roll_dice"]
|
||||
|
||||
await handler("test_sid", {"game_id": str(mock_game_state.game_id)})
|
||||
|
||||
# Should process the roll and broadcast
|
||||
mock_dice.roll_ab.assert_called_once()
|
||||
mock_manager.broadcast_to_game.assert_called_once()
|
||||
call_args = mock_manager.broadcast_to_game.call_args
|
||||
assert call_args[0][1] == "dice_rolled"
|
||||
998
backend/tests/unit/websocket/test_substitution_handlers.py
Normal file
998
backend/tests/unit/websocket/test_substitution_handlers.py
Normal file
@ -0,0 +1,998 @@
|
||||
"""
|
||||
Tests for WebSocket substitution handlers.
|
||||
|
||||
Covers all three substitution types:
|
||||
- Pinch hitter (batting substitution)
|
||||
- Defensive replacement (field substitution)
|
||||
- Pitching change (pitcher substitution)
|
||||
|
||||
Each handler follows the same pattern: validate input, acquire lock,
|
||||
call SubstitutionManager, broadcast results.
|
||||
|
||||
Author: Claude
|
||||
Date: 2025-01-27
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import pytest
|
||||
from contextlib import asynccontextmanager
|
||||
from uuid import uuid4
|
||||
from unittest.mock import AsyncMock, MagicMock, patch
|
||||
|
||||
from app.core.substitution_manager import SubstitutionResult
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# TEST FIXTURES
|
||||
# ============================================================================
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_sub_result_success():
|
||||
"""Create a successful substitution result."""
|
||||
return SubstitutionResult(
|
||||
success=True,
|
||||
player_out_lineup_id=1,
|
||||
player_in_card_id=999,
|
||||
new_lineup_id=100,
|
||||
new_position="CF",
|
||||
new_batting_order=1,
|
||||
error_message=None,
|
||||
error_code=None,
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_sub_result_failure():
|
||||
"""Create a failed substitution result."""
|
||||
return SubstitutionResult(
|
||||
success=False,
|
||||
player_out_lineup_id=1,
|
||||
player_in_card_id=999,
|
||||
new_lineup_id=None,
|
||||
new_position=None,
|
||||
new_batting_order=None,
|
||||
error_message="Player not found in roster",
|
||||
error_code="PLAYER_NOT_IN_ROSTER",
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def base_sub_data():
|
||||
"""Base data for substitution requests."""
|
||||
return {
|
||||
"game_id": str(uuid4()),
|
||||
"player_out_lineup_id": 1,
|
||||
"player_in_card_id": 999,
|
||||
"team_id": 1,
|
||||
}
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# PINCH HITTER TESTS
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class TestPinchHitter:
|
||||
"""Tests for request_pinch_hitter handler."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_pinch_hitter_success(
|
||||
self, mock_manager, mock_game_state, mock_sub_result_success
|
||||
):
|
||||
"""
|
||||
Verify successful pinch hitter substitution.
|
||||
|
||||
Should call SubstitutionManager.pinch_hit(), broadcast player_substituted,
|
||||
and confirm to requester.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
@asynccontextmanager
|
||||
async def mock_lock(game_id, timeout=30.0):
|
||||
yield
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr, \
|
||||
patch("app.websocket.handlers.SubstitutionManager") as MockSubMgr:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
mock_state_mgr.game_lock = mock_lock
|
||||
|
||||
mock_sub_instance = MagicMock()
|
||||
mock_sub_instance.pinch_hit = AsyncMock(return_value=mock_sub_result_success)
|
||||
MockSubMgr.return_value = mock_sub_instance
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_pinch_hitter"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(mock_game_state.game_id),
|
||||
"player_out_lineup_id": 1,
|
||||
"player_in_card_id": 999,
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
# Verify SubstitutionManager called
|
||||
mock_sub_instance.pinch_hit.assert_called_once()
|
||||
|
||||
# Verify broadcast
|
||||
mock_manager.broadcast_to_game.assert_called()
|
||||
broadcast_call = mock_manager.broadcast_to_game.call_args
|
||||
assert broadcast_call[0][1] == "player_substituted"
|
||||
assert broadcast_call[0][2]["type"] == "pinch_hitter"
|
||||
|
||||
# Verify confirmation to requester
|
||||
mock_manager.emit_to_user.assert_called()
|
||||
confirm_call = mock_manager.emit_to_user.call_args
|
||||
assert confirm_call[0][1] == "substitution_confirmed"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_pinch_hitter_missing_game_id(self, mock_manager):
|
||||
"""Verify error when game_id is missing."""
|
||||
from socketio import AsyncServer
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
sio = AsyncServer()
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_pinch_hitter"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{"player_out_lineup_id": 1, "player_in_card_id": 999, "team_id": 1},
|
||||
)
|
||||
|
||||
mock_manager.emit_to_user.assert_called_once()
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "substitution_error"
|
||||
assert "MISSING_FIELD" in call_args[0][2]["code"]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_pinch_hitter_invalid_game_id(self, mock_manager):
|
||||
"""Verify error when game_id is invalid UUID."""
|
||||
from socketio import AsyncServer
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
sio = AsyncServer()
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_pinch_hitter"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": "not-a-uuid",
|
||||
"player_out_lineup_id": 1,
|
||||
"player_in_card_id": 999,
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "substitution_error"
|
||||
assert "INVALID_FORMAT" in call_args[0][2]["code"]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_pinch_hitter_game_not_found(self, mock_manager):
|
||||
"""Verify error when game doesn't exist."""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
mock_state_mgr.get_state.return_value = None
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_pinch_hitter"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(uuid4()),
|
||||
"player_out_lineup_id": 1,
|
||||
"player_in_card_id": 999,
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert "not found" in call_args[0][2]["message"]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_pinch_hitter_missing_player_out(self, mock_manager, mock_game_state):
|
||||
"""Verify error when player_out_lineup_id is missing."""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_pinch_hitter"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(mock_game_state.game_id),
|
||||
"player_in_card_id": 999,
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "substitution_error"
|
||||
assert "player_out" in call_args[0][2]["message"].lower()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_pinch_hitter_missing_player_in(self, mock_manager, mock_game_state):
|
||||
"""Verify error when player_in_card_id is missing."""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_pinch_hitter"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(mock_game_state.game_id),
|
||||
"player_out_lineup_id": 1,
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "substitution_error"
|
||||
assert "player_in" in call_args[0][2]["message"].lower()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_pinch_hitter_missing_team_id(self, mock_manager, mock_game_state):
|
||||
"""Verify error when team_id is missing."""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_pinch_hitter"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(mock_game_state.game_id),
|
||||
"player_out_lineup_id": 1,
|
||||
"player_in_card_id": 999,
|
||||
},
|
||||
)
|
||||
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "substitution_error"
|
||||
assert "team_id" in call_args[0][2]["message"].lower()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_pinch_hitter_validation_failure(
|
||||
self, mock_manager, mock_game_state, mock_sub_result_failure
|
||||
):
|
||||
"""Verify SubstitutionManager failure is propagated to user."""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
@asynccontextmanager
|
||||
async def mock_lock(game_id, timeout=30.0):
|
||||
yield
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr, \
|
||||
patch("app.websocket.handlers.SubstitutionManager") as MockSubMgr:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
mock_state_mgr.game_lock = mock_lock
|
||||
|
||||
mock_sub_instance = MagicMock()
|
||||
mock_sub_instance.pinch_hit = AsyncMock(return_value=mock_sub_result_failure)
|
||||
MockSubMgr.return_value = mock_sub_instance
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_pinch_hitter"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(mock_game_state.game_id),
|
||||
"player_out_lineup_id": 1,
|
||||
"player_in_card_id": 999,
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "substitution_error"
|
||||
assert call_args[0][2]["code"] == "PLAYER_NOT_IN_ROSTER"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_pinch_hitter_lock_timeout(self, mock_manager, mock_game_state):
|
||||
"""Verify lock timeout returns server busy message."""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
@asynccontextmanager
|
||||
async def timeout_lock(game_id, timeout=30.0):
|
||||
raise asyncio.TimeoutError("Lock timeout")
|
||||
yield
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
mock_state_mgr.game_lock = timeout_lock
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_pinch_hitter"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(mock_game_state.game_id),
|
||||
"player_out_lineup_id": 1,
|
||||
"player_in_card_id": 999,
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "error"
|
||||
assert "busy" in call_args[0][2]["message"].lower()
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# DEFENSIVE REPLACEMENT TESTS
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class TestDefensiveReplacement:
|
||||
"""Tests for request_defensive_replacement handler."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_defensive_replacement_success(
|
||||
self, mock_manager, mock_game_state, mock_sub_result_success
|
||||
):
|
||||
"""Verify successful defensive replacement."""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
@asynccontextmanager
|
||||
async def mock_lock(game_id, timeout=30.0):
|
||||
yield
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr, \
|
||||
patch("app.websocket.handlers.SubstitutionManager") as MockSubMgr:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
mock_state_mgr.game_lock = mock_lock
|
||||
|
||||
mock_sub_instance = MagicMock()
|
||||
mock_sub_instance.defensive_replace = AsyncMock(
|
||||
return_value=mock_sub_result_success
|
||||
)
|
||||
MockSubMgr.return_value = mock_sub_instance
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_defensive_replacement"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(mock_game_state.game_id),
|
||||
"player_out_lineup_id": 1,
|
||||
"player_in_card_id": 999,
|
||||
"new_position": "CF",
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
# Verify SubstitutionManager called with position
|
||||
mock_sub_instance.defensive_replace.assert_called_once()
|
||||
call_kwargs = mock_sub_instance.defensive_replace.call_args[1]
|
||||
assert call_kwargs["new_position"] == "CF"
|
||||
|
||||
# Verify broadcast type
|
||||
broadcast_call = mock_manager.broadcast_to_game.call_args
|
||||
assert broadcast_call[0][2]["type"] == "defensive_replacement"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_defensive_replacement_missing_game_id(self, mock_manager):
|
||||
"""Verify error when game_id is missing."""
|
||||
from socketio import AsyncServer
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
sio = AsyncServer()
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_defensive_replacement"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"player_out_lineup_id": 1,
|
||||
"player_in_card_id": 999,
|
||||
"new_position": "CF",
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "substitution_error"
|
||||
assert "MISSING_FIELD" in call_args[0][2]["code"]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_defensive_replacement_invalid_game_id(self, mock_manager):
|
||||
"""Verify error when game_id is invalid."""
|
||||
from socketio import AsyncServer
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
sio = AsyncServer()
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_defensive_replacement"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": "invalid",
|
||||
"player_out_lineup_id": 1,
|
||||
"player_in_card_id": 999,
|
||||
"new_position": "CF",
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert "INVALID_FORMAT" in call_args[0][2]["code"]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_defensive_replacement_game_not_found(self, mock_manager):
|
||||
"""Verify error when game doesn't exist."""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
mock_state_mgr.get_state.return_value = None
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_defensive_replacement"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(uuid4()),
|
||||
"player_out_lineup_id": 1,
|
||||
"player_in_card_id": 999,
|
||||
"new_position": "CF",
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
assert "not found" in mock_manager.emit_to_user.call_args[0][2]["message"]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_defensive_replacement_missing_position(
|
||||
self, mock_manager, mock_game_state
|
||||
):
|
||||
"""Verify error when new_position is missing."""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_defensive_replacement"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(mock_game_state.game_id),
|
||||
"player_out_lineup_id": 1,
|
||||
"player_in_card_id": 999,
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "substitution_error"
|
||||
assert "position" in call_args[0][2]["message"].lower()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_defensive_replacement_validation_failure(
|
||||
self, mock_manager, mock_game_state, mock_sub_result_failure
|
||||
):
|
||||
"""Verify SubstitutionManager failure is propagated."""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
@asynccontextmanager
|
||||
async def mock_lock(game_id, timeout=30.0):
|
||||
yield
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr, \
|
||||
patch("app.websocket.handlers.SubstitutionManager") as MockSubMgr:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
mock_state_mgr.game_lock = mock_lock
|
||||
|
||||
mock_sub_instance = MagicMock()
|
||||
mock_sub_instance.defensive_replace = AsyncMock(
|
||||
return_value=mock_sub_result_failure
|
||||
)
|
||||
MockSubMgr.return_value = mock_sub_instance
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_defensive_replacement"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(mock_game_state.game_id),
|
||||
"player_out_lineup_id": 1,
|
||||
"player_in_card_id": 999,
|
||||
"new_position": "CF",
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "substitution_error"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_defensive_replacement_lock_timeout(
|
||||
self, mock_manager, mock_game_state
|
||||
):
|
||||
"""Verify lock timeout returns server busy message."""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
@asynccontextmanager
|
||||
async def timeout_lock(game_id, timeout=30.0):
|
||||
raise asyncio.TimeoutError("Lock timeout")
|
||||
yield
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
mock_state_mgr.game_lock = timeout_lock
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_defensive_replacement"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(mock_game_state.game_id),
|
||||
"player_out_lineup_id": 1,
|
||||
"player_in_card_id": 999,
|
||||
"new_position": "CF",
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert "busy" in call_args[0][2]["message"].lower()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_defensive_replacement_missing_player_out(
|
||||
self, mock_manager, mock_game_state
|
||||
):
|
||||
"""
|
||||
Verify error when player_out_lineup_id is missing.
|
||||
|
||||
Defensive replacement requires specifying which player is being replaced.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_defensive_replacement"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(mock_game_state.game_id),
|
||||
"player_in_card_id": 999,
|
||||
"new_position": "CF",
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "substitution_error"
|
||||
assert "player_out" in call_args[0][2]["message"].lower()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_defensive_replacement_missing_player_in(
|
||||
self, mock_manager, mock_game_state
|
||||
):
|
||||
"""
|
||||
Verify error when player_in_card_id is missing.
|
||||
|
||||
Defensive replacement requires specifying which player is entering.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_defensive_replacement"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(mock_game_state.game_id),
|
||||
"player_out_lineup_id": 1,
|
||||
"new_position": "CF",
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "substitution_error"
|
||||
assert "player_in" in call_args[0][2]["message"].lower()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_defensive_replacement_missing_team_id(
|
||||
self, mock_manager, mock_game_state
|
||||
):
|
||||
"""
|
||||
Verify error when team_id is missing.
|
||||
|
||||
Defensive replacement must specify which team is making the substitution.
|
||||
"""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_defensive_replacement"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(mock_game_state.game_id),
|
||||
"player_out_lineup_id": 1,
|
||||
"player_in_card_id": 999,
|
||||
"new_position": "CF",
|
||||
},
|
||||
)
|
||||
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "substitution_error"
|
||||
assert "team_id" in call_args[0][2]["message"].lower()
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# PITCHING CHANGE TESTS
|
||||
# ============================================================================
|
||||
|
||||
|
||||
class TestPitchingChange:
|
||||
"""Tests for request_pitching_change handler."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_pitching_change_success(
|
||||
self, mock_manager, mock_game_state, mock_sub_result_success
|
||||
):
|
||||
"""Verify successful pitching change."""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
mock_sub_result_success.new_position = "P" # Override for pitcher
|
||||
|
||||
@asynccontextmanager
|
||||
async def mock_lock(game_id, timeout=30.0):
|
||||
yield
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr, \
|
||||
patch("app.websocket.handlers.SubstitutionManager") as MockSubMgr:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
mock_state_mgr.game_lock = mock_lock
|
||||
|
||||
mock_sub_instance = MagicMock()
|
||||
mock_sub_instance.change_pitcher = AsyncMock(
|
||||
return_value=mock_sub_result_success
|
||||
)
|
||||
MockSubMgr.return_value = mock_sub_instance
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_pitching_change"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(mock_game_state.game_id),
|
||||
"player_out_lineup_id": 1,
|
||||
"player_in_card_id": 999,
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
mock_sub_instance.change_pitcher.assert_called_once()
|
||||
|
||||
broadcast_call = mock_manager.broadcast_to_game.call_args
|
||||
assert broadcast_call[0][2]["type"] == "pitching_change"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_pitching_change_missing_game_id(self, mock_manager):
|
||||
"""Verify error when game_id is missing."""
|
||||
from socketio import AsyncServer
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
sio = AsyncServer()
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_pitching_change"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{"player_out_lineup_id": 1, "player_in_card_id": 999, "team_id": 1},
|
||||
)
|
||||
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert "MISSING_FIELD" in call_args[0][2]["code"]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_pitching_change_invalid_game_id(self, mock_manager):
|
||||
"""Verify error when game_id is invalid."""
|
||||
from socketio import AsyncServer
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
sio = AsyncServer()
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_pitching_change"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": "bad-uuid",
|
||||
"player_out_lineup_id": 1,
|
||||
"player_in_card_id": 999,
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert "INVALID_FORMAT" in call_args[0][2]["code"]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_pitching_change_game_not_found(self, mock_manager):
|
||||
"""Verify error when game doesn't exist."""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
mock_state_mgr.get_state.return_value = None
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_pitching_change"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(uuid4()),
|
||||
"player_out_lineup_id": 1,
|
||||
"player_in_card_id": 999,
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
assert "not found" in mock_manager.emit_to_user.call_args[0][2]["message"]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_pitching_change_missing_player_out(
|
||||
self, mock_manager, mock_game_state
|
||||
):
|
||||
"""Verify error when player_out_lineup_id is missing."""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_pitching_change"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(mock_game_state.game_id),
|
||||
"player_in_card_id": 999,
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "substitution_error"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_pitching_change_missing_player_in(
|
||||
self, mock_manager, mock_game_state
|
||||
):
|
||||
"""Verify error when player_in_card_id is missing."""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_pitching_change"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(mock_game_state.game_id),
|
||||
"player_out_lineup_id": 1,
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "substitution_error"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_pitching_change_missing_team_id(self, mock_manager, mock_game_state):
|
||||
"""Verify error when team_id is missing."""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_pitching_change"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(mock_game_state.game_id),
|
||||
"player_out_lineup_id": 1,
|
||||
"player_in_card_id": 999,
|
||||
},
|
||||
)
|
||||
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "substitution_error"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_pitching_change_validation_failure(
|
||||
self, mock_manager, mock_game_state, mock_sub_result_failure
|
||||
):
|
||||
"""Verify SubstitutionManager failure is propagated."""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
@asynccontextmanager
|
||||
async def mock_lock(game_id, timeout=30.0):
|
||||
yield
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr, \
|
||||
patch("app.websocket.handlers.SubstitutionManager") as MockSubMgr:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
mock_state_mgr.game_lock = mock_lock
|
||||
|
||||
mock_sub_instance = MagicMock()
|
||||
mock_sub_instance.change_pitcher = AsyncMock(
|
||||
return_value=mock_sub_result_failure
|
||||
)
|
||||
MockSubMgr.return_value = mock_sub_instance
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_pitching_change"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(mock_game_state.game_id),
|
||||
"player_out_lineup_id": 1,
|
||||
"player_in_card_id": 999,
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert call_args[0][1] == "substitution_error"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_pitching_change_lock_timeout(self, mock_manager, mock_game_state):
|
||||
"""Verify lock timeout returns server busy message."""
|
||||
from socketio import AsyncServer
|
||||
|
||||
sio = AsyncServer()
|
||||
|
||||
@asynccontextmanager
|
||||
async def timeout_lock(game_id, timeout=30.0):
|
||||
raise asyncio.TimeoutError("Lock timeout")
|
||||
yield
|
||||
|
||||
with patch("app.websocket.handlers.state_manager") as mock_state_mgr:
|
||||
mock_state_mgr.get_state.return_value = mock_game_state
|
||||
mock_state_mgr.game_lock = timeout_lock
|
||||
|
||||
from app.websocket.handlers import register_handlers
|
||||
|
||||
register_handlers(sio, mock_manager)
|
||||
handler = sio.handlers["/"]["request_pitching_change"]
|
||||
|
||||
await handler(
|
||||
"test_sid",
|
||||
{
|
||||
"game_id": str(mock_game_state.game_id),
|
||||
"player_out_lineup_id": 1,
|
||||
"player_in_card_id": 999,
|
||||
"team_id": 1,
|
||||
},
|
||||
)
|
||||
|
||||
call_args = mock_manager.emit_to_user.call_args
|
||||
assert "busy" in call_args[0][2]["message"].lower()
|
||||
Loading…
Reference in New Issue
Block a user