File size: 4,413 Bytes
8d992b4
 
 
 
 
 
 
924784f
8d992b4
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
924784f
 
 
 
 
 
 
 
 
 
 
 
8d992b4
924784f
 
 
 
 
8d992b4
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
"""Tests for session state management functions."""

from unittest.mock import patch

import pandas as pd

from src.config import DIFFICULTY_PRESETS
from src.state.session import get_away_stats, get_home_team_df, init_session_state


class TestInitSessionState:
    """Tests for init_session_state."""

    def test_initializes_all_expected_keys(self) -> None:
        """Verify all default keys are created."""
        state: dict = {}
        with patch("src.state.session.st") as mock_st:
            mock_st.session_state = state
            init_session_state()

        expected_keys = {
            "home_team",
            "away_team",
            "away_team_df",
            "away_stats",
            "home_team_df",
            "radio_index",
        }
        assert set(state.keys()) == expected_keys

    def test_does_not_overwrite_existing_values(self) -> None:
        """Verify calling init twice does not overwrite existing values."""
        state: dict = {"home_team": ["Player A"]}
        with patch("src.state.session.st") as mock_st:
            mock_st.session_state = state
            init_session_state()

        assert state["home_team"] == ["Player A"]

    def test_sets_correct_default_away_stats(self) -> None:
        """Verify away_stats defaults to Regular difficulty preset."""
        state: dict = {}
        with patch("src.state.session.st") as mock_st:
            mock_st.session_state = state
            init_session_state()

        assert state["away_stats"] == list(DIFFICULTY_PRESETS["Regular"])

    def test_sets_empty_dataframes_by_default(self) -> None:
        """Verify DataFrames start empty."""
        state: dict = {}
        with patch("src.state.session.st") as mock_st:
            mock_st.session_state = state
            init_session_state()

        assert isinstance(state["away_team_df"], pd.DataFrame)
        assert state["away_team_df"].empty
        assert isinstance(state["home_team_df"], pd.DataFrame)
        assert state["home_team_df"].empty


class TestGetAwayStats:
    """Tests for get_away_stats."""

    def test_returns_stats_from_session(self) -> None:
        """Verify returns stats when properly set in session."""
        state: dict = {"away_stats": [100, 200, 300, 400]}
        with patch("src.state.session.st") as mock_st:
            mock_st.session_state = state
            result = get_away_stats()

        assert result == [100, 200, 300, 400]

    def test_returns_defaults_when_invalid(self) -> None:
        """Verify returns defaults when away_stats is invalid."""
        state: dict = {"away_stats": "invalid"}
        with patch("src.state.session.st") as mock_st:
            mock_st.session_state = state
            result = get_away_stats()

        assert result == list(DIFFICULTY_PRESETS["Regular"])

    def test_returns_defaults_on_none(self) -> None:
        """Verify returns defaults when away_stats is None."""
        state: dict = {"away_stats": None}
        with patch("src.state.session.st") as mock_st:
            mock_st.session_state = state
            result = get_away_stats()

        assert result == list(DIFFICULTY_PRESETS["Regular"])

    def test_returns_defaults_on_wrong_length(self) -> None:
        """Verify returns defaults when away_stats has wrong length."""
        state: dict = {"away_stats": [1, 2, 3]}
        with patch("src.state.session.st") as mock_st:
            mock_st.session_state = state
            result = get_away_stats()

        assert result == list(DIFFICULTY_PRESETS["Regular"])


class TestGetHomeTeamDf:
    """Tests for get_home_team_df."""

    def test_returns_dataframe_from_session(self) -> None:
        """Verify returns DataFrame when set in session."""
        expected_df = pd.DataFrame({"FULL_NAME": ["Player A"]})
        state: dict = {"home_team_df": expected_df}
        with patch("src.state.session.st") as mock_st:
            mock_st.session_state = state
            result = get_home_team_df()

        pd.testing.assert_frame_equal(result, expected_df)

    def test_returns_empty_dataframe_when_not_set(self) -> None:
        """Verify returns empty DataFrame when not set."""
        state: dict = {}
        with patch("src.state.session.st") as mock_st:
            mock_st.session_state = state
            result = get_home_team_df()

        assert isinstance(result, pd.DataFrame)
        assert result.empty