316 lines
15 KiB
Python
316 lines
15 KiB
Python
"""Tests for pitcher decision logic in get_db_ready_decisions."""
|
|
|
|
import pytest
|
|
from sqlmodel import Session
|
|
|
|
from in_game.gameplay_queries import get_db_ready_decisions
|
|
from in_game.gameplay_models import Game, Team, Player, Lineup, Play, Cardset, Card
|
|
from tests.factory import session_fixture
|
|
|
|
|
|
class TestPitcherDecisions:
|
|
"""Test pitcher decision scenarios (Win, Loss, Save, Hold, Blown Save)."""
|
|
|
|
def get_factory_game_and_lineups(self, session: Session) -> tuple[Game, dict[str, Lineup]]:
|
|
"""Get existing game and lineups from factory data."""
|
|
# Use existing game from factory: Game 3 (teams 69 vs 420, active=True)
|
|
game = session.get(Game, 3)
|
|
|
|
# Factory creates lineups with these IDs:
|
|
# Team 69 (away): lineup IDs 21-30, pitcher (position P, batting_order=10) = ID 30
|
|
# Team 420 (home): lineup IDs 31-40, pitcher (position P, batting_order=10) = ID 40
|
|
away_starter = session.get(Lineup, 30) # Team 69 pitcher, player_id=30
|
|
home_starter = session.get(Lineup, 40) # Team 420 pitcher, player_id=40
|
|
|
|
# Get some batters for creating plays (batting_order=1 = leadoff hitter)
|
|
away_batter = session.get(Lineup, 21) # Team 69 leadoff hitter
|
|
home_batter = session.get(Lineup, 31) # Team 420 leadoff hitter
|
|
|
|
return game, {
|
|
'away_starter': away_starter,
|
|
'home_starter': home_starter,
|
|
'away_batter': away_batter,
|
|
'home_batter': home_batter
|
|
}
|
|
|
|
def create_play(self, session: Session, game: Game, play_num: int, inning_num: int,
|
|
inning_half: str, pitcher: Lineup, batter: Lineup, away_score: int = 0, home_score: int = 0,
|
|
is_go_ahead: bool = False, is_tied: bool = False) -> Play:
|
|
"""Helper to create a play with specified parameters matching factory pattern."""
|
|
play = Play(
|
|
game=game,
|
|
play_num=play_num,
|
|
inning_num=inning_num,
|
|
inning_half=inning_half,
|
|
pitcher=pitcher,
|
|
batter=batter,
|
|
batter_pos=batter.position,
|
|
away_score=away_score,
|
|
home_score=home_score,
|
|
is_go_ahead=is_go_ahead,
|
|
is_tied=is_tied,
|
|
batting_order=batter.batting_order,
|
|
pa=1,
|
|
ab=1,
|
|
complete=True
|
|
)
|
|
session.add(play)
|
|
return play
|
|
|
|
def test_basic_win_loss_home_team_wins(self, session: Session):
|
|
"""Test basic win/loss when home team wins."""
|
|
game, lineups = self.get_factory_game_and_lineups(session)
|
|
away_starter = lineups['away_starter']
|
|
home_starter = lineups['home_starter']
|
|
away_batter = lineups['away_batter']
|
|
home_batter = lineups['home_batter']
|
|
|
|
# Game where home team wins 3-2
|
|
# Away team takes lead 2-0
|
|
self.create_play(session, game, 1, 1, 'top', home_starter, away_batter, 1, 0, is_go_ahead=True)
|
|
self.create_play(session, game, 2, 2, 'top', home_starter, away_batter, 2, 0, is_go_ahead=True)
|
|
|
|
# Home team comes back to win 3-2
|
|
self.create_play(session, game, 3, 3, 'bot', away_starter, home_batter, 2, 1)
|
|
self.create_play(session, game, 4, 4, 'bot', away_starter, home_batter, 2, 2, is_tied=True)
|
|
self.create_play(session, game, 5, 5, 'bot', away_starter, home_batter, 2, 3, is_go_ahead=True)
|
|
|
|
session.commit()
|
|
|
|
decisions = get_db_ready_decisions(session, game, 3)
|
|
decision_dict = {d['pitcher_id']: d for d in decisions}
|
|
|
|
# Home starter should get the win (pitcher of record when team took lead)
|
|
assert decision_dict[40]['win'] == 1 # Player ID 40 = home starter
|
|
assert decision_dict[40]['loss'] == 0
|
|
|
|
# Away starter should get the loss (gave up go-ahead run)
|
|
assert decision_dict[30]['win'] == 0 # Player ID 30 = away starter
|
|
assert decision_dict[30]['loss'] == 1
|
|
|
|
def test_basic_win_loss_away_team_wins(self, session: Session):
|
|
"""Test basic win/loss when away team wins."""
|
|
game, lineups = self.setup_test_game_with_pitchers(session)
|
|
away_starter, home_starter = lineups[0], lineups[1]
|
|
|
|
# Game where away team wins 4-2
|
|
# Away team takes early lead
|
|
self.create_play(session, game, 1, 1, 'top', home_starter, 2, 0, is_go_ahead=True)
|
|
self.create_play(session, game, 2, 2, 'top', home_starter, 4, 0, is_go_ahead=True)
|
|
|
|
# Home team scores but doesn't catch up
|
|
self.create_play(session, game, 3, 3, 'bot', away_starter, 4, 2)
|
|
|
|
session.commit()
|
|
|
|
decisions = get_db_ready_decisions(session, game, 3)
|
|
decision_dict = {d['pitcher_id']: d for d in decisions}
|
|
|
|
# Away starter should get the win
|
|
assert decision_dict[200]['win'] == 1
|
|
assert decision_dict[200]['loss'] == 0
|
|
|
|
# Home starter should get the loss
|
|
assert decision_dict[201]['win'] == 0
|
|
assert decision_dict[201]['loss'] == 1
|
|
|
|
def test_home_team_save_situation(self, session: Session):
|
|
"""Test save situation for home team pitcher."""
|
|
game, lineups = self.setup_test_game_with_pitchers(session)
|
|
away_starter, home_starter, _, _, _, home_closer = lineups[0], lineups[1], lineups[2], lineups[3], lineups[4], lineups[5]
|
|
|
|
# Home team leads 3-1, closer comes in during 7th inning (final_inning = 9)
|
|
self.create_play(session, game, 1, 1, 'top', home_starter, 0, 3, is_go_ahead=True)
|
|
self.create_play(session, game, 2, 2, 'top', home_starter, 1, 3)
|
|
|
|
# Home closer enters in 7th inning (within final 3 innings)
|
|
# Lead is ≤ 3 runs, closer is not starter
|
|
self.create_play(session, game, 3, 7, 'top', home_closer, 1, 3)
|
|
self.create_play(session, game, 4, 9, 'top', home_closer, 1, 3) # Final inning
|
|
|
|
session.commit()
|
|
|
|
decisions = get_db_ready_decisions(session, game, 3)
|
|
decision_dict = {d['pitcher_id']: d for d in decisions}
|
|
|
|
# Home closer should get the save
|
|
assert decision_dict[205]['is_save'] == 1
|
|
assert decision_dict[205]['hold'] == 0
|
|
|
|
def test_away_team_save_situation(self, session: Session):
|
|
"""Test save situation for away team pitcher (our new fix)."""
|
|
game, lineups = self.setup_test_game_with_pitchers(session)
|
|
away_starter, home_starter, away_reliever, _ = lineups[0], lineups[1], lineups[2], lineups[3]
|
|
|
|
# Away team leads 4-1, reliever comes in during 7th inning
|
|
self.create_play(session, game, 1, 1, 'top', home_starter, 4, 0, is_go_ahead=True)
|
|
self.create_play(session, game, 2, 2, 'bot', away_starter, 4, 1)
|
|
|
|
# Away reliever enters in 7th inning bottom half
|
|
# Lead is ≤ 3 runs, reliever is not starter
|
|
self.create_play(session, game, 3, 7, 'bot', away_reliever, 4, 1)
|
|
self.create_play(session, game, 4, 9, 'bot', away_reliever, 4, 1) # Final inning
|
|
|
|
session.commit()
|
|
|
|
decisions = get_db_ready_decisions(session, game, 3)
|
|
decision_dict = {d['pitcher_id']: d for d in decisions}
|
|
|
|
# Away reliever should get the save (this tests our new away team save logic)
|
|
assert decision_dict[10]['is_save'] == 1 # Player ID 10 = away reliever
|
|
assert decision_dict[10]['hold'] == 0
|
|
|
|
def test_hold_situation(self, session: Session):
|
|
"""Test hold situation for reliever."""
|
|
game, lineups = self.setup_test_game_with_pitchers(session)
|
|
away_starter, home_starter, _, home_reliever, _, home_closer = lineups[0], lineups[1], lineups[2], lineups[3], lineups[4], lineups[5]
|
|
|
|
# Home team leads, reliever enters in save situation but gets replaced
|
|
self.create_play(session, game, 1, 1, 'top', home_starter, 0, 3, is_go_ahead=True)
|
|
|
|
# Home reliever enters in save situation (7th inning, 3-run lead)
|
|
self.create_play(session, game, 2, 7, 'top', home_reliever, 1, 3)
|
|
|
|
# Home closer enters and finishes game (reliever should get hold)
|
|
self.create_play(session, game, 3, 8, 'top', home_closer, 1, 3)
|
|
self.create_play(session, game, 4, 9, 'top', home_closer, 1, 3)
|
|
|
|
session.commit()
|
|
|
|
decisions = get_db_ready_decisions(session, game, 3)
|
|
decision_dict = {d['pitcher_id']: d for d in decisions}
|
|
|
|
# Home reliever should get a hold
|
|
assert decision_dict[203]['hold'] == 1
|
|
assert decision_dict[203]['is_save'] == 0
|
|
|
|
# Home closer should get the save
|
|
assert decision_dict[205]['is_save'] == 1
|
|
assert decision_dict[205]['hold'] == 0
|
|
|
|
def test_blown_save_situation(self, session: Session):
|
|
"""Test blown save situation."""
|
|
game, lineups = self.setup_test_game_with_pitchers(session)
|
|
away_starter, home_starter, _, _, _, home_closer = lineups[0], lineups[1], lineups[2], lineups[3], lineups[4], lineups[5]
|
|
|
|
# Home team leads, closer enters in save situation but blows it
|
|
self.create_play(session, game, 1, 1, 'top', home_starter, 0, 3, is_go_ahead=True)
|
|
|
|
# Home closer enters in save situation
|
|
self.create_play(session, game, 2, 7, 'top', home_closer, 1, 3)
|
|
|
|
# Game gets tied (blown save)
|
|
self.create_play(session, game, 3, 8, 'top', home_closer, 3, 3, is_tied=True)
|
|
|
|
# Home team wins it in bottom 9th
|
|
self.create_play(session, game, 4, 9, 'bot', away_starter, 3, 4, is_go_ahead=True)
|
|
|
|
session.commit()
|
|
|
|
decisions = get_db_ready_decisions(session, game, 3)
|
|
decision_dict = {d['pitcher_id']: d for d in decisions}
|
|
|
|
# Home closer should get a blown save
|
|
assert decision_dict[205]['b_save'] == 1
|
|
assert decision_dict[205]['is_save'] == 0
|
|
|
|
def test_save_timing_logic_fix(self, session: Session):
|
|
"""Test that save timing logic works correctly (inning_num >= final_inning - 2)."""
|
|
game, lineups = self.setup_test_game_with_pitchers(session)
|
|
away_starter, home_starter, _, _, _, home_closer = lineups[0], lineups[1], lineups[2], lineups[3], lineups[4], lineups[5]
|
|
|
|
# Set up game that goes 9 innings (final_inning = 9)
|
|
self.create_play(session, game, 1, 1, 'top', home_starter, 0, 2, is_go_ahead=True)
|
|
|
|
# Closer enters in 7th inning (7 >= 9-2 = True, should qualify for save)
|
|
self.create_play(session, game, 2, 7, 'top', home_closer, 1, 2)
|
|
self.create_play(session, game, 3, 9, 'top', home_closer, 1, 2)
|
|
|
|
session.commit()
|
|
|
|
decisions = get_db_ready_decisions(session, game, 3)
|
|
decision_dict = {d['pitcher_id']: d for d in decisions}
|
|
|
|
# Should get save with corrected timing logic
|
|
assert decision_dict[205]['is_save'] == 1
|
|
|
|
def test_null_winner_loser_handling(self, session: Session):
|
|
"""Test that null winner/loser doesn't crash the function."""
|
|
game, lineups = self.setup_test_game_with_pitchers(session)
|
|
away_starter, home_starter = lineups[0], lineups[1]
|
|
|
|
# Create a game with no clear go-ahead plays (edge case)
|
|
self.create_play(session, game, 1, 1, 'top', home_starter, 0, 0)
|
|
self.create_play(session, game, 2, 9, 'bot', away_starter, 0, 1) # Home wins 1-0
|
|
|
|
session.commit()
|
|
|
|
# This should not crash even if winner/loser logic has issues
|
|
decisions = get_db_ready_decisions(session, game, 3)
|
|
|
|
# Should return decisions without crashing
|
|
assert len(decisions) > 0
|
|
|
|
# Check that starter flags are set safely
|
|
decision_dict = {d['pitcher_id']: d for d in decisions}
|
|
assert decision_dict[200]['is_start'] is True # Away starter
|
|
assert decision_dict[201]['is_start'] is True # Home starter
|
|
|
|
def test_starter_safety_checks(self, session: Session):
|
|
"""Test that null starter checks don't crash."""
|
|
game, lineups = self.setup_test_game_with_pitchers(session)
|
|
away_starter, home_starter = lineups[0], lineups[1]
|
|
|
|
# Create basic game
|
|
self.create_play(session, game, 1, 1, 'top', home_starter, 0, 1, is_go_ahead=True)
|
|
|
|
session.commit()
|
|
|
|
decisions = get_db_ready_decisions(session, game, 3)
|
|
decision_dict = {d['pitcher_id']: d for d in decisions}
|
|
|
|
# Starters should be properly identified
|
|
assert decision_dict[200]['is_start'] is True
|
|
assert decision_dict[201]['is_start'] is True
|
|
assert decision_dict[200]['game_finished'] == 1 # Away finisher
|
|
assert decision_dict[201]['game_finished'] == 1 # Home finisher
|
|
|
|
def test_fallback_winner_loser_logic(self, session: Session):
|
|
"""Test improved winner/loser fallback logic using final game state."""
|
|
game, lineups = self.setup_test_game_with_pitchers(session)
|
|
away_starter, home_starter, _, home_reliever = lineups[0], lineups[1], lineups[2], lineups[3]
|
|
|
|
# Create game where go-ahead logic might not work perfectly
|
|
# but final score clearly shows winner
|
|
self.create_play(session, game, 1, 1, 'top', home_starter, 1, 0)
|
|
self.create_play(session, game, 2, 9, 'bot', away_starter, 1, 3) # Home wins 3-1
|
|
|
|
session.commit()
|
|
|
|
decisions = get_db_ready_decisions(session, game, 3)
|
|
decision_dict = {d['pitcher_id']: d for d in decisions}
|
|
|
|
# With fallback logic, should determine winner from final score
|
|
# Since home team won, home finisher should be winner if no other winner found
|
|
# This tests the new fallback logic we implemented
|
|
assert len([d for d in decisions if d.get('win', 0) == 1]) == 1 # Exactly one winner
|
|
assert len([d for d in decisions if d.get('loss', 0) == 1]) == 1 # Exactly one loser
|
|
|
|
|
|
class TestPitcherDecisionEdgeCases:
|
|
"""Test edge cases and complex scenarios for pitcher decisions."""
|
|
|
|
def test_extra_innings_decisions(self, session: Session):
|
|
"""Test decisions in extra innings game."""
|
|
# This would test the final_inning calculation for games beyond 9 innings
|
|
pass # Implement if extra innings logic is needed
|
|
|
|
def test_multiple_blown_saves_same_pitcher(self, session: Session):
|
|
"""Test pitcher who blows multiple saves in same game."""
|
|
# Edge case where same pitcher enters multiple save situations
|
|
pass # Implement if this scenario occurs
|
|
|
|
def test_starter_goes_distance_for_save(self, session: Session):
|
|
"""Test starter who goes complete game in save situation."""
|
|
# Edge case where starter != reliever save logic needs to be bypassed
|
|
pass # Implement based on specific rule requirements |