559fe73f07
## Player Model Migration - Migrate Player model from Discord app following Model/Service Architecture pattern - Extract all business logic from Player model to PlayerService - Create pure data model with PostgreSQL relationships (Cardset, PositionRating) - Implement comprehensive PlayerFactory with specialized methods for test data ## PlayerService Implementation - Extract 5 business logic methods from original Player model: - get_batter_card_url() - batting card URL retrieval - get_pitcher_card_url() - pitching card URL retrieval - generate_name_card_link() - markdown link generation - get_formatted_name_with_description() - name formatting - get_player_description() - description from object or dict - Follow BaseService pattern with dependency injection and logging ## Comprehensive Testing - 35 passing Player tests (14 model + 21 service tests) - PlayerFactory with specialized methods (batting/pitching cards, positions) - Test isolation following factory pattern and db_session guidelines - Fix PostgreSQL integer overflow in test ID generation ## Integration Test Infrastructure - Create integration test framework for improving service coverage - Design AIService integration tests targeting uncovered branches - Demonstrate real database query testing with proper isolation - Establish patterns for testing complex game scenarios ## Service Coverage Analysis - Current service coverage: 61% overall - PlayerService: 100% coverage (excellent migration example) - AIService: 60% coverage (improvement opportunities identified) - Integration test strategy designed to achieve 90%+ coverage ## Database Integration - Update Cardset model to include players relationship - Update PositionRating model with proper Player foreign key - Maintain all existing relationships and constraints - Demonstrate data isolation and automatic cleanup in tests ## Test Suite Status - 137 tests passing, 0 failures (maintained 100% pass rate) - Added 35 new tests while preserving all existing functionality - Integration test infrastructure ready for coverage improvements 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
501 lines
19 KiB
Python
501 lines
19 KiB
Python
"""
|
|
AIService Integration Tests
|
|
|
|
Tests AIService with real database interactions, complex game scenarios,
|
|
and end-to-end business logic flows that aren't covered by unit tests.
|
|
|
|
These tests focus on:
|
|
1. Real database queries and relationships
|
|
2. Complex conditional logic branches
|
|
3. Error handling with actual data
|
|
4. Cross-service interactions
|
|
5. Edge cases with realistic game states
|
|
"""
|
|
import pytest
|
|
from sqlmodel import select
|
|
|
|
from app.models.ai_responses import JumpResponse, TagResponse, ThrowResponse, DefenseResponse
|
|
from app.models.manager_ai import ManagerAi
|
|
from app.models.player import Player
|
|
from app.models.position_rating import PositionRating
|
|
from app.services.ai_service import AIService
|
|
from tests.factories.manager_ai_factory import ManagerAiFactory
|
|
from tests.factories.player_factory import PlayerFactory
|
|
|
|
|
|
class TestAIServiceDatabaseIntegration:
|
|
"""Test AIService with real database interactions."""
|
|
|
|
def test_check_steal_opportunity_with_real_database_queries(self, db_session):
|
|
"""Test steal decisions with actual database queries for catcher defense."""
|
|
# Create real game scenario with catcher and pitcher
|
|
catcher = PlayerFactory.create_catcher(db_session, name="Real Catcher")
|
|
|
|
# Create actual position rating for catcher
|
|
catcher_defense = PositionRating(
|
|
player_id=catcher.id,
|
|
variant=0,
|
|
position='C',
|
|
arm=8, # Strong arm
|
|
range=6,
|
|
error=2
|
|
)
|
|
db_session.add(catcher_defense)
|
|
db_session.commit()
|
|
|
|
# Create manager AI and mock game with realistic setup
|
|
aggressive_ai = ManagerAiFactory.create(db_session, steal=9, running=8)
|
|
mock_game = self._create_realistic_game_mock(catcher, db_session)
|
|
|
|
ai_service = AIService(db_session)
|
|
|
|
# Test steal to second with real database query
|
|
result = ai_service.check_steal_opportunity(aggressive_ai, mock_game, 2)
|
|
|
|
assert isinstance(result, JumpResponse)
|
|
assert result.min_safe is not None
|
|
# Should factor in real catcher arm strength (8)
|
|
assert hasattr(result, 'run_if_auto_jump')
|
|
|
|
def test_steal_opportunity_complex_conditional_branches(self, db_session):
|
|
"""Test uncovered conditional branches in steal logic."""
|
|
# Test case: steal > 8 and run_diff <= 5 (line 91)
|
|
high_steal_ai = ManagerAiFactory.create(db_session, steal=9)
|
|
catcher = PlayerFactory.create_catcher(db_session)
|
|
self._create_catcher_defense(catcher, db_session, arm=5)
|
|
|
|
mock_game = self._create_realistic_game_mock(catcher, db_session)
|
|
mock_game.current_play_or_none.return_value.ai_run_diff = 2 # <= 5
|
|
mock_game.current_play_or_none.return_value.outs = 1
|
|
|
|
ai_service = AIService(db_session)
|
|
result = ai_service.check_steal_opportunity(high_steal_ai, mock_game, 2)
|
|
|
|
# Should hit line 91: min_safe = 13 + num_outs = 14
|
|
assert result.min_safe == 14
|
|
|
|
def test_steal_opportunity_edge_case_branches(self, db_session):
|
|
"""Test edge case branches that are uncovered."""
|
|
# Test case: steal > 6 and run_diff <= 5 (line 93)
|
|
medium_steal_ai = ManagerAiFactory.create(db_session, steal=7)
|
|
catcher = PlayerFactory.create_catcher(db_session)
|
|
self._create_catcher_defense(catcher, db_session, arm=4)
|
|
|
|
mock_game = self._create_realistic_game_mock(catcher, db_session)
|
|
mock_game.current_play_or_none.return_value.ai_run_diff = 3
|
|
mock_game.current_play_or_none.return_value.outs = 0
|
|
|
|
ai_service = AIService(db_session)
|
|
result = ai_service.check_steal_opportunity(medium_steal_ai, mock_game, 2)
|
|
|
|
# Should hit line 93: min_safe = 14 + num_outs = 14
|
|
assert result.min_safe == 14
|
|
|
|
def test_steal_to_home_scenario(self, db_session):
|
|
"""Test steal to home logic with real runner setup."""
|
|
# Test uncovered steal to home scenario (lines 151-171)
|
|
balanced_ai = ManagerAiFactory.create(db_session, steal=6)
|
|
|
|
# Create runner on third with real batting card
|
|
runner_on_third = PlayerFactory.create(db_session, name="Fast Runner")
|
|
catcher = PlayerFactory.create_catcher(db_session)
|
|
self._create_catcher_defense(catcher, db_session, arm=6)
|
|
|
|
mock_game = self._create_steal_home_game_mock(runner_on_third, catcher, db_session)
|
|
|
|
ai_service = AIService(db_session)
|
|
result = ai_service.check_steal_opportunity(balanced_ai, mock_game, 4) # Home = 4
|
|
|
|
assert isinstance(result, JumpResponse)
|
|
# Should hit steal > 5 branch (line 160): min_safe = 7
|
|
assert result.min_safe == 7
|
|
|
|
def test_pitcher_replacement_with_real_database_queries(self, db_session):
|
|
"""Test pitcher replacement with actual game stats queries."""
|
|
# Create realistic pitcher replacement scenario
|
|
balanced_ai = ManagerAiFactory.create(db_session, behind_aggression=5, ahead_aggression=5)
|
|
|
|
# Mock game will need to return data for real SQL queries
|
|
mock_game = self._create_pitcher_replacement_mock(db_session)
|
|
|
|
ai_service = AIService(db_session)
|
|
|
|
# Mock the session.exec calls to return realistic data
|
|
ai_service.session.exec = self._mock_pitcher_stats_queries
|
|
|
|
result = ai_service.should_replace_pitcher(balanced_ai, mock_game)
|
|
|
|
assert isinstance(result, bool)
|
|
# Test that complex pitcher logic executes without errors
|
|
|
|
def test_defensive_alignment_with_real_position_ratings(self, db_session):
|
|
"""Test defensive alignment with actual position rating queries."""
|
|
balanced_ai = ManagerAiFactory.create(db_session, defense=6)
|
|
catcher = PlayerFactory.create_catcher(db_session, name="Defensive Catcher")
|
|
|
|
# Create real position rating
|
|
self._create_catcher_defense(catcher, db_session, arm=9, range=7)
|
|
|
|
mock_game = self._create_defense_alignment_mock(catcher, db_session)
|
|
|
|
ai_service = AIService(db_session)
|
|
result = ai_service.set_defensive_alignment(balanced_ai, mock_game)
|
|
|
|
assert isinstance(result, DefenseResponse)
|
|
assert result.ai_note is not None
|
|
|
|
def test_tag_decisions_complex_scenarios(self, db_session):
|
|
"""Test tag decision logic with realistic game states."""
|
|
# Test tag from second with complex aggression calculations
|
|
aggressive_ai = ManagerAiFactory.create(
|
|
db_session,
|
|
running=8,
|
|
ahead_aggression=7,
|
|
behind_aggression=3
|
|
)
|
|
|
|
mock_game = self._create_tag_scenario_mock(db_session)
|
|
|
|
ai_service = AIService(db_session)
|
|
result = ai_service.check_tag_from_second(aggressive_ai, mock_game)
|
|
|
|
assert isinstance(result, TagResponse)
|
|
assert result.min_safe is not None
|
|
|
|
# Helper methods for creating realistic mocks and database data
|
|
|
|
def _create_realistic_game_mock(self, catcher, db_session):
|
|
"""Create a realistic game mock with proper runner and catcher setup."""
|
|
from unittest.mock import Mock
|
|
|
|
mock_game = Mock()
|
|
mock_play = Mock()
|
|
|
|
# Create realistic runner on first
|
|
runner = PlayerFactory.create(db_session, name="Base Runner")
|
|
mock_runner = Mock()
|
|
mock_runner.player.name = runner.name
|
|
mock_runner.card.batterscouting.battingcard.steal_auto = False
|
|
mock_runner.card.batterscouting.battingcard.steal_high = 14
|
|
mock_runner.card.batterscouting.battingcard.steal_low = 11
|
|
|
|
mock_play.on_first = mock_runner
|
|
mock_play.catcher = Mock()
|
|
mock_play.catcher.player_id = catcher.id
|
|
mock_play.catcher.card.variant = 0
|
|
mock_play.pitcher.card.pitcherscouting.pitchingcard.hold = 5
|
|
mock_play.outs = 1
|
|
mock_play.ai_run_diff = 2
|
|
|
|
mock_game.current_play_or_none.return_value = mock_play
|
|
mock_game.id = 12345
|
|
|
|
return mock_game
|
|
|
|
def _create_catcher_defense(self, catcher, db_session, arm=5, range=5):
|
|
"""Create position rating for catcher."""
|
|
defense = PositionRating(
|
|
player_id=catcher.id,
|
|
variant=0,
|
|
position='C',
|
|
arm=arm,
|
|
range=range,
|
|
error=1
|
|
)
|
|
db_session.add(defense)
|
|
db_session.commit()
|
|
return defense
|
|
|
|
def _create_steal_home_game_mock(self, runner, catcher, db_session):
|
|
"""Create game mock for steal to home scenario."""
|
|
from unittest.mock import Mock
|
|
|
|
mock_game = Mock()
|
|
mock_play = Mock()
|
|
|
|
mock_runner = Mock()
|
|
mock_runner.player.name = runner.name
|
|
mock_runner.card.batterscouting.battingcard.steal_low = 12
|
|
|
|
mock_play.on_third = mock_runner
|
|
mock_play.catcher = Mock()
|
|
mock_play.catcher.player_id = catcher.id
|
|
mock_play.catcher.card.variant = 0
|
|
mock_play.pitcher.card.pitcherscouting.pitchingcard.hold = 4
|
|
mock_play.ai_run_diff = 0 # Tied game
|
|
mock_play.inning_num = 8 # Late inning
|
|
|
|
mock_game.current_play_or_none.return_value = mock_play
|
|
mock_game.id = 67890
|
|
|
|
return mock_game
|
|
|
|
def _create_pitcher_replacement_mock(self, db_session):
|
|
"""Create mock for pitcher replacement testing."""
|
|
from unittest.mock import Mock
|
|
|
|
mock_game = Mock()
|
|
mock_play = Mock()
|
|
|
|
mock_pitcher = Mock()
|
|
mock_pitcher.replacing_id = None # Starter
|
|
mock_pitcher.is_fatigued = True
|
|
mock_pitcher.card.pitcherscouting.pitchingcard.starter_rating = 6
|
|
mock_pitcher.card.player.name_with_desc = "Test Starter"
|
|
|
|
mock_play.pitcher = mock_pitcher
|
|
mock_play.on_base_code = 3 # Runners on base
|
|
mock_play.ai_run_diff = -1 # Behind by 1
|
|
mock_play.inning_num = 6
|
|
|
|
mock_game.current_play_or_none.return_value = mock_play
|
|
mock_game.id = 11111
|
|
|
|
return mock_game
|
|
|
|
def _create_defense_alignment_mock(self, catcher, db_session):
|
|
"""Create mock for defensive alignment testing."""
|
|
from unittest.mock import Mock
|
|
|
|
mock_game = Mock()
|
|
mock_play = Mock()
|
|
|
|
mock_play.on_third = Mock()
|
|
mock_play.on_third.player.name = "Runner on Third"
|
|
mock_play.could_walkoff = True
|
|
mock_play.starting_outs = 1
|
|
mock_play.catcher = Mock()
|
|
mock_play.catcher.player_id = catcher.id
|
|
mock_play.catcher.card.variant = 0
|
|
|
|
mock_game.current_play_or_none.return_value = mock_play
|
|
mock_game.id = 22222
|
|
|
|
return mock_game
|
|
|
|
def _create_tag_scenario_mock(self, db_session):
|
|
"""Create mock for tag decision testing."""
|
|
from unittest.mock import Mock
|
|
|
|
mock_game = Mock()
|
|
mock_play = Mock()
|
|
|
|
mock_play.starting_outs = 1
|
|
mock_play.ai_run_diff = 3 # Ahead by 3
|
|
|
|
mock_game.current_play_or_none.return_value = mock_play
|
|
mock_game.id = 33333
|
|
|
|
return mock_game
|
|
|
|
def _mock_pitcher_stats_queries(self, query):
|
|
"""Mock database queries for pitcher stats."""
|
|
from unittest.mock import Mock
|
|
|
|
mock_result = Mock()
|
|
mock_result.one.side_effect = [21, 6] # 21 outs, 6 allowed runners
|
|
return mock_result
|
|
|
|
|
|
class TestAIServiceErrorHandling:
|
|
"""Test error handling scenarios that aren't covered."""
|
|
|
|
def test_check_steal_missing_catcher_defense(self, db_session):
|
|
"""Test error when catcher has no defensive rating."""
|
|
ai = ManagerAiFactory.create(db_session, steal=5)
|
|
catcher = PlayerFactory.create_catcher(db_session)
|
|
# Don't create position rating - should cause database error
|
|
|
|
mock_game = self._create_basic_game_mock(catcher, db_session)
|
|
|
|
ai_service = AIService(db_session)
|
|
|
|
# Should handle missing position rating gracefully
|
|
with pytest.raises(Exception): # Database error for missing rating
|
|
ai_service.check_steal_opportunity(ai, mock_game, 2)
|
|
|
|
def test_steal_opportunity_missing_runner(self, db_session):
|
|
"""Test error handling when expected runner is missing."""
|
|
ai = ManagerAiFactory.create(db_session, steal=5)
|
|
catcher = PlayerFactory.create_catcher(db_session)
|
|
|
|
mock_game = self._create_basic_game_mock(catcher, db_session)
|
|
mock_game.current_play_or_none.return_value.on_first = None # No runner
|
|
|
|
ai_service = AIService(db_session)
|
|
|
|
with pytest.raises(ValueError, match="no runner found on first"):
|
|
ai_service.check_steal_opportunity(ai, mock_game, 2)
|
|
|
|
def test_steal_to_home_missing_runner_on_third(self, db_session):
|
|
"""Test error handling for steal to home with no runner on third."""
|
|
ai = ManagerAiFactory.create(db_session, steal=5)
|
|
catcher = PlayerFactory.create_catcher(db_session)
|
|
|
|
mock_game = self._create_basic_game_mock(catcher, db_session)
|
|
mock_game.current_play_or_none.return_value.ai_run_diff = 0 # Trigger home steal logic
|
|
mock_game.current_play_or_none.return_value.on_third = None # No runner
|
|
|
|
ai_service = AIService(db_session)
|
|
|
|
with pytest.raises(ValueError, match="no runner found on third"):
|
|
ai_service.check_steal_opportunity(ai, mock_game, 4)
|
|
|
|
def _create_basic_game_mock(self, catcher, db_session):
|
|
"""Create basic game mock for error testing."""
|
|
from unittest.mock import Mock
|
|
|
|
mock_game = Mock()
|
|
mock_play = Mock()
|
|
|
|
mock_runner = Mock()
|
|
mock_runner.player.name = "Test Runner"
|
|
mock_runner.card.batterscouting.battingcard.steal_auto = False
|
|
|
|
mock_play.on_first = mock_runner
|
|
mock_play.catcher = Mock()
|
|
mock_play.catcher.player_id = catcher.id
|
|
mock_play.catcher.card.variant = 0
|
|
mock_play.pitcher.card.pitcherscouting.pitchingcard.hold = 5
|
|
mock_play.outs = 1
|
|
mock_play.ai_run_diff = 2
|
|
|
|
mock_game.current_play_or_none.return_value = mock_play
|
|
mock_game.id = 99999
|
|
|
|
return mock_game
|
|
|
|
|
|
class TestAIServiceCrossServiceIntegration:
|
|
"""Test AIService interactions with other services and complex game flows."""
|
|
|
|
def test_ai_service_with_player_service_integration(self, db_session):
|
|
"""Test AIService using PlayerService for player descriptions."""
|
|
from app.services.player_service import PlayerService
|
|
|
|
# Create realistic game scenario
|
|
ai = ManagerAiFactory.create(db_session, steal=7)
|
|
runner = PlayerFactory.create(db_session, name="Speed Demon", description="2023 Rookie")
|
|
catcher = PlayerFactory.create_catcher(db_session)
|
|
self._create_catcher_position(catcher, db_session)
|
|
|
|
mock_game = self._create_runner_game_mock(runner, catcher, db_session)
|
|
|
|
ai_service = AIService(db_session)
|
|
player_service = PlayerService(db_session)
|
|
|
|
# Test that AI notes could use PlayerService formatting
|
|
result = ai_service.check_steal_opportunity(ai, mock_game, 2)
|
|
|
|
# Verify PlayerService can format the runner name consistently
|
|
formatted_name = player_service.get_formatted_name_with_description(runner)
|
|
assert "2023 Rookie Speed Demon" == formatted_name
|
|
|
|
# AI service should work independently but could integrate with PlayerService
|
|
assert isinstance(result, JumpResponse)
|
|
|
|
def test_complex_game_state_decision_chain(self, db_session):
|
|
"""Test complex decision chain covering multiple AI methods."""
|
|
# Create comprehensive game scenario
|
|
ai = ManagerAiFactory.create(
|
|
db_session,
|
|
steal=8,
|
|
running=7,
|
|
defense=6,
|
|
ahead_aggression=8,
|
|
behind_aggression=4
|
|
)
|
|
|
|
catcher = PlayerFactory.create_catcher(db_session, name="Elite Catcher")
|
|
runner = PlayerFactory.create(db_session, name="Speedster")
|
|
|
|
self._create_catcher_position(catcher, db_session, arm=9)
|
|
|
|
mock_game = self._create_complex_game_mock(runner, catcher, db_session)
|
|
|
|
ai_service = AIService(db_session)
|
|
|
|
# Test multiple AI decisions in sequence
|
|
steal_result = ai_service.check_steal_opportunity(ai, mock_game, 2)
|
|
tag_result = ai_service.check_tag_from_second(ai, mock_game)
|
|
defense_result = ai_service.set_defensive_alignment(ai, mock_game)
|
|
|
|
# All should execute without errors and return proper responses
|
|
assert isinstance(steal_result, JumpResponse)
|
|
assert isinstance(tag_result, TagResponse)
|
|
assert isinstance(defense_result, DefenseResponse)
|
|
|
|
def _create_catcher_position(self, catcher, db_session, arm=7):
|
|
"""Helper to create catcher position rating."""
|
|
rating = PositionRating(
|
|
player_id=catcher.id,
|
|
variant=0,
|
|
position='C',
|
|
arm=arm,
|
|
range=6,
|
|
error=1
|
|
)
|
|
db_session.add(rating)
|
|
db_session.commit()
|
|
|
|
def _create_runner_game_mock(self, runner, catcher, db_session):
|
|
"""Create game mock with specific runner."""
|
|
from unittest.mock import Mock
|
|
|
|
mock_game = Mock()
|
|
mock_play = Mock()
|
|
|
|
mock_runner = Mock()
|
|
mock_runner.player.name = runner.name
|
|
mock_runner.card.batterscouting.battingcard.steal_auto = True
|
|
mock_runner.card.batterscouting.battingcard.steal_high = 16
|
|
|
|
mock_play.on_first = mock_runner
|
|
mock_play.catcher = Mock()
|
|
mock_play.catcher.player_id = catcher.id
|
|
mock_play.catcher.card.variant = 0
|
|
mock_play.pitcher.card.pitcherscouting.pitchingcard.hold = 4
|
|
mock_play.outs = 0
|
|
mock_play.ai_run_diff = 1
|
|
|
|
mock_game.current_play_or_none.return_value = mock_play
|
|
mock_game.id = 55555
|
|
|
|
return mock_game
|
|
|
|
def _create_complex_game_mock(self, runner, catcher, db_session):
|
|
"""Create complex game scenario for testing multiple decisions."""
|
|
from unittest.mock import Mock
|
|
|
|
mock_game = Mock()
|
|
mock_play = Mock()
|
|
|
|
# Setup for steal decision
|
|
mock_runner = Mock()
|
|
mock_runner.player.name = runner.name
|
|
mock_runner.card.batterscouting.battingcard.steal_auto = False
|
|
mock_runner.card.batterscouting.battingcard.steal_high = 15
|
|
mock_runner.card.batterscouting.battingcard.steal_low = 12
|
|
|
|
# Setup for tag decision
|
|
mock_play.on_first = mock_runner
|
|
mock_play.on_second = mock_runner # Same runner for tag test
|
|
mock_play.starting_outs = 1
|
|
|
|
# Setup for defense decision
|
|
mock_play.on_third = mock_runner
|
|
mock_play.could_walkoff = False
|
|
|
|
# Common setup
|
|
mock_play.catcher = Mock()
|
|
mock_play.catcher.player_id = catcher.id
|
|
mock_play.catcher.card.variant = 0
|
|
mock_play.pitcher.card.pitcherscouting.pitchingcard.hold = 5
|
|
mock_play.outs = 1
|
|
mock_play.ai_run_diff = 2
|
|
mock_play.on_base_code = 7 # Runners on 1st, 2nd, 3rd
|
|
|
|
mock_game.current_play_or_none.return_value = mock_play
|
|
mock_game.id = 77777
|
|
|
|
return mock_game |