PyTest¶

@pytest.fixture
def data_dir() -> Path:
    """Code tests will output data to this directory."""
    return Path(__file__).parent / "test_output"

@pytest.fixture
def yahoo_data(data_dir: Union[Path, str]) -> Data:
    """Instantiate yfpy Data object."""
    return Data(data_dir)

@pytest.fixture
def yahoo_query(league_id: str, game_code: str, game_id: int, browser_callback: bool) -> YahooFantasySportsQuery:
    """Instantiate yfpy YahooFantasySportsQuery object and override league key."""
    yahoo_query = YahooFantasySportsQuery(
        league_id,
        game_code,
        game_id=game_id,
        yahoo_consumer_key=os.environ.get("YFPY_CONSUMER_KEY"),
        yahoo_consumer_secret=os.environ.get("YFPY_CONSUMER_SECRET"),
        env_file_location=Path(__file__).parent.parent.parent / "env",
        all_output_as_json_str=False,
        browser_callback=browser_callback,
        offline=False,
    )

    # Manually override league key for example code to work
    yahoo_query.league_key = f"{game_id}.l.{league_id}"

    return yahoo_query

@pytest.fixture
def browser_callback() -> bool:
    """Turn on/off automatic opening of browser window for OAuth."""
    browser_callback = True
    return browser_callback

@pytest.fixture
def season() -> int:
    """Set Yahoo Fantasy Sports season for testing."""
    return quickstart.get_season()

@pytest.fixture
def chosen_week() -> int:
    """Set Yahoo Fantasy Sports chosen week for testing."""
    return quickstart.get_chosen_week()

@pytest.fixture
def chosen_date() -> str:
    """Set Yahoo Fantasy Sports chosen date for testing."""
    return quickstart.get_chosen_date()

@pytest.fixture
def game_code() -> str:
    """Set Yahoo Fantasy Sports game code for testing."""
    return quickstart.get_game_code()

@pytest.fixture
def game_id() -> int:
    """Set Yahoo Fantasy Sports game ID for testing."""
    return quickstart.get_game_id()

@pytest.fixture
def game_key() -> str:
    """Set Yahoo Fantasy Sports game key for testing."""
    return quickstart.get_game_key()

@pytest.fixture
def league_id() -> str:
    """Set Yahoo Fantasy Sports league ID for testing."""
    return quickstart.get_league_id()

@pytest.fixture
def team_id() -> int:
    """Set Yahoo Fantasy Sports team ID for testing."""
    return quickstart.get_team_id()

@pytest.fixture
def team_name() -> str:
    """Set Yahoo Fantasy Sports team name for testing."""
    return quickstart.get_team_name()

@pytest.fixture
def player_id() -> int:
    """Create and set Yahoo Fantasy Sports player ID for testing."""
    return quickstart.get_player_id()

@pytest.fixture
def player_key(game_id, player_id) -> str:
    """Create and set Yahoo Fantasy Sports player key for testing."""

    player_key = f"{game_id}.p.{player_id}"

    return player_key

@pytest.fixture
def league_player_limit() -> int:
    """Set Yahoo Fantasy Sports league player retrieval limit for testing."""
    return quickstart.get_league_player_limit()

@pytest.mark.integration
def test_get_all_yahoo_fantasy_game_keys(yahoo_query, yahoo_data, game_code, game_id, show_log_output):
    """Integration test for retrieval of all Yahoo fantasy football game keys.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_all_yahoo_fantasy_game_keys`.

    """
    query_result_data = yahoo_data.save(
        f"{game_code}-game_keys",
        yahoo_query.get_all_yahoo_fantasy_game_keys
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"{game_code}-game_keys",
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(f"{prettify_data(loaded_result_data)}\n----------\n")

    assert query_result_data == loaded_result_data

@pytest.mark.integration
def test_get_game_key_by_season(yahoo_query, season, game_key, show_log_output):
    """Integration test for retrieval of specific game key by season.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_game_key_by_season`.

    """
    query_result_data = yahoo_query.get_game_key_by_season(season=season)
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    assert query_result_data == game_key

@pytest.mark.integration
def test_get_current_game_info(yahoo_query, yahoo_data, data_dir, season, game_id, show_log_output):
    """Integration test for retrieval of game info for current fantasy season.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_current_game_info`.

    """
    query_result_data = yahoo_data.save(
        "current-game-info",
        yahoo_query.get_current_game_info
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        "current-game-info",
        Game,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.integration
def test_get_current_game_metadata(yahoo_query, yahoo_data, data_dir, season, game_id, show_log_output):
    """Integration test for retrieval of game metadata for current fantasy season.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_current_game_metadata`.

    """
    query_result_data = yahoo_data.save(
        "current-game-metadata",
        yahoo_query.get_current_game_metadata
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        "current-game-metadata",
        Game,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.integration
def test_get_game_info_by_game_id(yahoo_query, yahoo_data, data_dir, season, game_id, show_log_output):
    """Integration test for retrieval of game info for specific game by id.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_game_info_by_game_id`.

    """
    new_data_dir = data_dir / str(season)
    query_result_data = yahoo_data.save(
        f"{game_id}-game-info",
        yahoo_query.get_game_info_by_game_id,
        params={"game_id": game_id},
        new_data_dir=new_data_dir
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"{game_id}-game-info",
        Game,
        new_data_dir=new_data_dir,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.integration
def test_get_game_metadata_by_game_id(yahoo_query, yahoo_data, data_dir, season, game_id, show_log_output):
    """Integration test for retrieval of game metadata for specific game by id.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_game_metadata_by_game_id`.

    """
    new_data_dir = data_dir / str(season)
    query_result_data = yahoo_data.save(
        f"{game_id}-game-metadata",
        yahoo_query.get_game_metadata_by_game_id,
        params={"game_id": game_id},
        new_data_dir=new_data_dir
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"{game_id}-game-metadata",
        Game,
        new_data_dir=new_data_dir,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.integration
def test_get_league_key(yahoo_query, yahoo_data, data_dir, season, game_id, league_id, show_log_output):
    """Integration test for retrieval of league key for selected league.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_league_key`.

    """
    query_result_data = yahoo_query.get_league_key()
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    assert query_result_data == f"{game_id}.l.{league_id}"

@pytest.mark.integration
def test_get_game_weeks_by_game_id(yahoo_query, yahoo_data, data_dir, season, game_id, show_log_output):
    """Integration test for retrieval of all valid weeks of a specific game by id.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_game_weeks_by_game_id`.

    """
    new_data_dir = data_dir / str(season)
    query_result_data = yahoo_data.save(
        f"{game_id}-game-weeks",
        yahoo_query.get_game_weeks_by_game_id,
        params={"game_id": game_id},
        new_data_dir=new_data_dir
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"{game_id}-game-weeks",
        new_data_dir=new_data_dir,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.integration
def test_get_game_stat_categories_by_game_id(yahoo_query, yahoo_data, data_dir, season, game_id, show_log_output):
    """Integration test for retrieval of all valid stat categories of a specific game by id.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_game_stat_categories_by_game_id`.

    """
    new_data_dir = data_dir / str(season)
    query_result_data = yahoo_data.save(
        f"{game_id}-game-stat_categories",
        yahoo_query.get_game_stat_categories_by_game_id,
        params={"game_id": game_id},
        new_data_dir=new_data_dir
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"{game_id}-game-stat_categories",
        StatCategories,
        new_data_dir=new_data_dir,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.integration
def test_get_game_position_types_by_game_id(yahoo_query, yahoo_data, data_dir, season, game_id, show_log_output):
    """Integration test for retrieval of all valid position types for specific game by id.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_game_position_types_by_game_id`.

    """
    new_data_dir = data_dir / str(season)
    query_result_data = yahoo_data.save(
        f"{game_id}-game-position_types",
        yahoo_query.get_game_position_types_by_game_id,
        params={"game_id": game_id},
        new_data_dir=new_data_dir
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"{game_id}-game-position_types",
        new_data_dir=new_data_dir,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.integration
def test_get_game_roster_positions_by_game_id(yahoo_query, yahoo_data, data_dir, season, game_id, show_log_output):
    """Integration test for retrieval of all valid roster positions for specific game by id.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_game_roster_positions_by_game_id`.

    """
    new_data_dir = data_dir / str(season)
    query_result_data = yahoo_data.save(
        f"{game_id}-game-roster_positions",
        yahoo_query.get_game_roster_positions_by_game_id,
        params={"game_id": game_id},
        new_data_dir=new_data_dir
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"{game_id}-game-roster_positions",
        new_data_dir=new_data_dir,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.integration
def test_get_league_info(yahoo_query, yahoo_data, data_dir, season, game_id, league_id, show_log_output):
    """Integration test for retrieval of info for chosen Yahoo fantasy league.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_league_info`.

    """

    new_data_dir = data_dir / str(season) / f"{game_id}.l.{league_id}"
    query_result_data = yahoo_data.save(
        f"{league_id}-league-info",
        yahoo_query.get_league_info,
        new_data_dir=new_data_dir
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"{league_id}-league-info",
        League,
        new_data_dir=new_data_dir,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.integration
def test_get_league_metadata(yahoo_query, yahoo_data, data_dir, season, game_id, league_id, show_log_output):
    """Integration test for retrieval of metadata for chosen Yahoo fantasy league..

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_league_metadata`.

    """
    new_data_dir = data_dir / str(season) / f"{game_id}.l.{league_id}"
    query_result_data = yahoo_data.save(
        f"{league_id}-league-metadata",
        yahoo_query.get_league_metadata,
        new_data_dir=new_data_dir
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"{league_id}-league-metadata",
        League,
        new_data_dir=new_data_dir,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.integration
def test_get_league_settings(yahoo_query, yahoo_data, data_dir, season, game_id, league_id, show_log_output):
    """Integration test for retrieval of settings for chosen Yahoo fantasy league.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_league_settings`.

    """
    new_data_dir = data_dir / str(season) / f"{game_id}.l.{league_id}"
    query_result_data = yahoo_data.save(
        f"{league_id}-league-settings",
        yahoo_query.get_league_settings,
        new_data_dir=new_data_dir
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"{league_id}-league-settings",
        Settings,
        new_data_dir=new_data_dir,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.integration
def test_get_league_standings(yahoo_query, yahoo_data, data_dir, season, game_id, league_id, show_log_output):
    """Integration test for retrieval of standings for chosen Yahoo fantasy league.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_league_standings`.

    """
    new_data_dir = data_dir / str(season) / f"{game_id}.l.{league_id}"
    query_result_data = yahoo_data.save(
        f"{league_id}-league-standings",
        yahoo_query.get_league_standings,
        new_data_dir=new_data_dir
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"{league_id}-league-standings",
        Standings,
        new_data_dir=new_data_dir,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.integration
def test_get_league_teams(yahoo_query, yahoo_data, data_dir, season, game_id, league_id, show_log_output):
    """Integration test for retrieval of all teams in chosen Yahoo fantasy league.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_league_teams`.

    """
    new_data_dir = data_dir / str(season) / f"{game_id}.l.{league_id}"
    query_result_data = yahoo_data.save(
        f"{league_id}-league-teams",
        yahoo_query.get_league_teams,
        new_data_dir=new_data_dir
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"{league_id}-league-teams",
        new_data_dir=new_data_dir,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.skip(
    reason="Skipping test_get_league_players: high player volume slows down tests. Run this test separately."
)
@pytest.mark.integration
def test_get_league_players(yahoo_query, yahoo_data, data_dir, season, game_id, league_id, show_log_output):
    """Integration test for retrieval of players in chosen Yahoo fantasy league.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_league_players`.

    """
    new_data_dir = data_dir / str(season) / f"{game_id}.l.{league_id}"
    query_result_data = yahoo_data.save(
        f"{league_id}-league-players",
        yahoo_query.get_league_players,
        # params={"player_count_start": 1400, "player_count_limit": 1475},
        new_data_dir=new_data_dir
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"{league_id}-league-players",
        new_data_dir=new_data_dir,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.integration
def test_get_league_players_with_limit(yahoo_query, yahoo_data, data_dir, season, game_id, league_id,
                                       league_player_limit, show_log_output):
    """Integration test for retrieval of a specified maximum of players in chosen Yahoo fantasy league.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_league_players`.

    """
    new_data_dir = data_dir / str(season) / f"{game_id}.l.{league_id}"
    query_result_data = yahoo_data.save(
        f"{league_id}-league-players",
        yahoo_query.get_league_players,
        params={"player_count_limit": league_player_limit},
        new_data_dir=new_data_dir
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"{league_id}-league-players",
        new_data_dir=new_data_dir,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.integration
def test_get_league_draft_results(yahoo_query, yahoo_data, data_dir, season, game_id, league_id, show_log_output):
    """Integration test for retrieval of draft results for chosen Yahoo fantasy league.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_league_draft_results`.

    """
    new_data_dir = data_dir / str(season) / f"{game_id}.l.{league_id}"
    query_result_data = yahoo_data.save(
        f"{league_id}-league-draft_results",
        yahoo_query.get_league_draft_results,
        new_data_dir=new_data_dir
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"{league_id}-league-draft_results",
        new_data_dir=new_data_dir,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.integration
def test_get_league_transactions(yahoo_query, yahoo_data, data_dir, season, game_id, league_id, show_log_output):
    """Integration test for retrieval of transactions for chosen Yahoo fantasy league.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_league_transactions`.

    """
    new_data_dir = data_dir / str(season) / f"{game_id}.l.{league_id}"
    query_result_data = yahoo_data.save(
        f"{league_id}-league-transactions",
        yahoo_query.get_league_transactions,
        new_data_dir=new_data_dir
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"{league_id}-league-transactions",
        new_data_dir=new_data_dir,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.integration
def test_get_league_scoreboard_by_week(yahoo_query, yahoo_data, data_dir, season, chosen_week, game_id, league_id,
                                       show_log_output):
    """Integration test for retrieval of scoreboard by week for chosen Yahoo fantasy league.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_league_scoreboard_by_week`.

    """
    new_data_dir = data_dir / str(season) / f"{game_id}.l.{league_id}" / f"week_{chosen_week}"
    query_result_data = yahoo_data.save(
        f"week_{chosen_week}-scoreboard",
        yahoo_query.get_league_scoreboard_by_week,
        params={"chosen_week": chosen_week},
        new_data_dir=new_data_dir
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"week_{chosen_week}-scoreboard",
        Scoreboard,
        new_data_dir=new_data_dir,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.integration
def test_get_league_matchups_by_week(yahoo_query, yahoo_data, data_dir, season, chosen_week, game_id, league_id,
                                     show_log_output):
    """Integration test for retrieval of matchups by week for chosen Yahoo fantasy league.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_league_matchups_by_week`.

    """
    new_data_dir = data_dir / str(season) / f"{game_id}.l.{league_id}" / f"week_{chosen_week}"
    query_result_data = yahoo_data.save(
        f"week_{chosen_week}-matchups",
        yahoo_query.get_league_matchups_by_week,
        params={"chosen_week": chosen_week},
        new_data_dir=new_data_dir
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"week_{chosen_week}-matchups",
        new_data_dir=new_data_dir,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.integration
def test_get_player_stats_for_season(yahoo_query, yahoo_data, data_dir, season, game_id, league_id, player_id,
                                     player_key, show_log_output):
    """Integration test for retrieval of player stats by season for chosen Yahoo fantasy league.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_player_stats_for_season`.

    """
    new_data_dir = data_dir / str(season) / f"{game_id}.l.{league_id}" / "players"
    query_result_data = yahoo_data.save(
        f"{player_id}-player-season-stats",
        yahoo_query.get_player_stats_for_season,
        params={"player_key": str(player_key)},
        new_data_dir=new_data_dir
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"{player_id}-player-season-stats",
        Player,
        new_data_dir=new_data_dir,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.integration
def test_get_player_stats_by_week(yahoo_query, yahoo_data, data_dir, season, chosen_week, game_id, league_id,
                                  player_id, player_key, show_log_output):
    """Integration test for retrieval of player stats by week for chosen Yahoo fantasy league..

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_player_stats_by_week`.

    """
    new_data_dir = data_dir / str(season) / f"{game_id}.l.{league_id}" / f"week_{chosen_week}" / "players"
    query_result_data = yahoo_data.save(
        f"{player_id}-player-stats",
        yahoo_query.get_player_stats_by_week,
        params={"player_key": str(player_key), "chosen_week": str(chosen_week)},
        new_data_dir=new_data_dir
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"{player_id}-player-stats",
        Player,
        new_data_dir=new_data_dir,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.skip(
    reason="Skipping test_get_player_stats_by_date: retrieval by date supported by NHL/NBA/MLB, not NFL."
)
@pytest.mark.integration
def test_get_player_stats_by_date(yahoo_query, yahoo_data, data_dir, season, chosen_date, game_id, league_id,
                                  player_id, player_key, show_log_output):
    """Integration test for retrieval of player stats by date for Yahoo fantasy league.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_player_stats_by_date`.

    """
    new_data_dir = data_dir / str(season) / f"{game_id}.l.{league_id}" / str(chosen_date) / "players"
    query_result_data = yahoo_data.save(
        f"{player_id}-player-stats",
        yahoo_query.get_player_stats_by_date,
        params={"player_key": str(player_key), "chosen_date": chosen_date},
        new_data_dir=new_data_dir
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"{player_id}-player-stats",
        Player,
        new_data_dir=new_data_dir,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.integration
def test_get_player_ownership(yahoo_query, yahoo_data, data_dir, season, game_id, league_id, player_id, player_key,
                              show_log_output):
    """Integration test for retrieval of ownership of chosen player for chosen Yahoo fantasy league.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_player_ownership`.

    """
    new_data_dir = data_dir / str(season) / f"{game_id}.l.{league_id}" / "players"
    query_result_data = yahoo_data.save(
        f"{player_id}-player-ownership",
        yahoo_query.get_player_ownership,
        params={"player_key": str(player_key)},
        new_data_dir=new_data_dir
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"{player_id}-player-ownership",
        Player,
        new_data_dir=new_data_dir,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.integration
def test_get_player_percent_owned_by_week(yahoo_query, yahoo_data, data_dir, season, chosen_week, game_id, league_id,
                                          player_id, player_key, show_log_output):
    """Integration test for retrieval of percent ownership by week of chosen player for chosen Yahoo fantasy league.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_player_percent_owned_by_week`.

    """
    new_data_dir = data_dir / str(season) / f"{game_id}.l.{league_id}" / f"week_{chosen_week}" / "players"
    query_result_data = yahoo_data.save(
        f"{player_id}-player-percent_owned",
        yahoo_query.get_player_percent_owned_by_week,
        params={"player_key": str(player_key), "chosen_week": str(chosen_week)},
        new_data_dir=new_data_dir
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"{player_id}-player-percent_owned",
        Player,
        new_data_dir=new_data_dir,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.integration
def test_get_player_draft_analysis(yahoo_query, yahoo_data, data_dir, season, game_id, league_id, player_id,
                                   player_key, show_log_output):
    """Integration test for retrieval of player draft analysis of chosen player for chosen Yahoo fantasy league.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_player_draft_analysis`.

    """
    new_data_dir = data_dir / str(season) / f"{game_id}.l.{league_id}" / "players"
    query_result_data = yahoo_data.save(
        f"{player_id}-player-draft_analysis",
        yahoo_query.get_player_draft_analysis,
        params={"player_key": str(player_key)}, new_data_dir=new_data_dir
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"{player_id}-player-draft_analysis",
        Player,
        new_data_dir=new_data_dir,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.integration
def test_get_team_info(yahoo_query, yahoo_data, data_dir, season, game_id, league_id, team_id, team_name,
                       show_log_output):
    """Integration test for retrieval of info for chosen team by team ID for chosen Yahoo fantasy league.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_team_info`.

    """
    new_data_dir = data_dir / str(season) / f"{game_id}.l.{league_id}" / "teams" / f"{team_id}-{team_name}"
    query_result_data = yahoo_data.save(
        f"{team_id}-{team_name}-info",
        yahoo_query.get_team_info,
        params={"team_id": team_id},
        new_data_dir=new_data_dir
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"{team_id}-{team_name}-info",
        Team,
        new_data_dir=new_data_dir,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.integration
def test_get_team_metadata(yahoo_query, yahoo_data, data_dir, season, game_id, league_id, team_id, team_name,
                           show_log_output):
    """Integration test for retrieval of metadata for chosen team by team ID for chosen Yahoo fantasy league.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_team_metadata`.

    """
    new_data_dir = data_dir / str(season) / f"{game_id}.l.{league_id}" / "teams" / f"{team_id}-{team_name}"
    query_result_data = yahoo_data.save(
        f"{team_id}-{team_name}-metadata",
        yahoo_query.get_team_metadata,
        params={"team_id": team_id},
        new_data_dir=new_data_dir
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"{team_id}-{team_name}-metadata",
        Team,
        new_data_dir=new_data_dir,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.integration
def test_get_team_stats(yahoo_query, yahoo_data, data_dir, season, game_id, league_id, team_id, team_name,
                        show_log_output):
    """Integration test for retrieval of stats for chosen team by team ID for chosen Yahoo fantasy league.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_team_stats`.

    """
    new_data_dir = data_dir / str(season) / f"{game_id}.l.{league_id}" / "teams" / f"{team_id}-{team_name}"
    query_result_data = yahoo_data.save(
        f"{team_id}-{team_name}-stats",
        yahoo_query.get_team_stats,
        params={"team_id": team_id},
        new_data_dir=new_data_dir
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"{team_id}-{team_name}-stats",
        TeamPoints,
        new_data_dir=new_data_dir,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.integration
def test_get_team_stats_by_week(yahoo_query, yahoo_data, data_dir, season, chosen_week, game_id, league_id, team_id,
                                team_name, show_log_output):
    """Integration test for retrieval of stats for chosen team by team ID and by week for chosen Yahoo fantasy league.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_team_stats_by_week`.

    """
    new_data_dir = data_dir / str(season) / f"{game_id}.l.{league_id}" / f"week_{chosen_week}"
    query_result_data = yahoo_data.save(
        f"{team_id}-{team_name}-stats",
        yahoo_query.get_team_stats_by_week,
        params={"team_id": team_id, "chosen_week": chosen_week},
        new_data_dir=new_data_dir
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"{team_id}-{team_name}-stats",
        new_data_dir=new_data_dir,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.integration
def test_get_team_standings(yahoo_query, yahoo_data, data_dir, season, game_id, league_id, team_id, team_name,
                            show_log_output):
    """Integration test for retrieval of standings for chosen team by team ID for chosen Yahoo fantasy league.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_team_standings`.

    """
    new_data_dir = data_dir / str(season) / f"{game_id}.l.{league_id}" / "teams" / f"{team_id}-{team_name}"
    query_result_data = yahoo_data.save(
        f"{team_id}-{team_name}-standings",
        yahoo_query.get_team_standings,
        params={"team_id": team_id},
        new_data_dir=new_data_dir
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"{team_id}-{team_name}-standings",
        TeamStandings,
        new_data_dir=new_data_dir,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.integration
def test_get_team_roster_by_week(yahoo_query, yahoo_data, data_dir, season, chosen_week, game_id, league_id, team_id,
                                 team_name, show_log_output):
    """Integration test for retrieval of roster for chosen team by team ID and by week for chosen Yahoo fantasy league.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_team_roster_by_week`.

    """
    new_data_dir = data_dir / str(season) / f"{game_id}.l.{league_id}" / f"week_{chosen_week}" / "rosters"
    query_result_data = yahoo_data.save(
        f"{team_id}-{team_name}-roster_by_week",
        yahoo_query.get_team_roster_by_week,
        params={"team_id": team_id, "chosen_week": chosen_week},
        new_data_dir=new_data_dir
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"{team_id}-{team_name}-roster_by_week",
        Roster,
        new_data_dir=new_data_dir,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data

@pytest.mark.integration
def test_get_team_roster_player_info_by_week(yahoo_query, yahoo_data, data_dir, season, chosen_week, game_id,
                                             league_id, team_id, team_name, show_log_output):
    """Integration test for retrieval of roster with player info for chosen team by team ID and by week for chosen Yahoo
    fantasy league.

    Note:
        Tests :func:`~yfpy.query.YahooFantasySportsQuery.get_team_roster_player_info_by_week`.

    """
    new_data_dir = data_dir / str(season) / f"{game_id}.l.{league_id}" / f"week_{chosen_week}" / "rosters"
    query_result_data = yahoo_data.save(
        f"{team_id}-{team_name}-roster-player_info_by_week",
        yahoo_query.get_team_roster_player_info_by_week,
        params={"team_id": team_id, "chosen_week": chosen_week},
        new_data_dir=new_data_dir
    )
    if show_log_output:
        logger.info(prettify_data(query_result_data))

    loaded_result_data = yahoo_data.load(
        f"{team_id}-{team_name}-roster-player_info_by_week",
        new_data_dir=new_data_dir,
        all_output_as_json_str=yahoo_query.all_output_as_json_str
    )
    if show_log_output:
        logger.info(prettify_data(loaded_result_data))

    assert query_result_data == loaded_result_data