refactor: add tests for pagination and players resource

Author: zombyacoff

.ruff.toml

@@ -51,7 +51,7 @@ ignore-names = ["env", "pages"]
 
 [lint.per-file-ignores]
 "__init__.py" = [
-    "RUF067", # Code is present in `__init__.py`
+    "RUF067",  # Code is present in `__init__.py`
 ]
 "examples/*" = [
     "ICN003",  # Import a member from the module instead of importing the member directly
@@ -61,20 +61,28 @@ ignore-names = ["env", "pages"]
     "T201",    # `print()` statement detected
 ]
 "exceptions.py" = [
-    "E302", # Expected 2 blank lines before top-level definitions
-    "E305", # Expected 2 blank lines after a class or function definition
+    "E302",    # Expected 2 blank lines before top-level definitions
+    "E305",    # Expected 2 blank lines after a class or function definition
 ]
 "docs/*" = ["ALL"]
 "scripts/*" = [
-    "T201",   # `print()` statement detected
-    "INP001", # Missing `__init__.py` file in a package directory
+    "T201",    # `print()` statement detected
+    "INP001",  # Missing `__init__.py` file in a package directory
+]
+"tests/*" = [
+    "PLR0917", # Too many positional arguments
+    "PLC1901", # Compare to empty string (e.g., `x == ""` instead of `not x`)
+    "PLC2701", # Import of a private name from an external module
+    "PLR2004", # Magic value used in a comparison
+    "PLR6301", # Method could be a function, class method, or static method (doesn't use `self`)
+    "PT011",   # `pytest.raises()` is too broad, set the `match` parameter
+    "PT030",   # `pytest.warns()` is too broad, set the `match` parameter
 ]
-"tests/*" = ["ALL"]
 "types.py" = [
-    "E302",   # Expected 2 blank lines before top-level definitions
-    "F401",   # Imported but unused
-    "ICN003", # Import a member from the module instead of importing the member directly
-    "PYI018", # Unused private `TypeVar`, `ParamSpec`, or `TypeVarTuple` declaration
+    "E302",    # Expected 2 blank lines before top-level definitions
+    "F401",    # Imported but unused
+    "ICN003",  # Import a member from the module instead of importing the member directly
+    "PYI018",  # Unused private `TypeVar`, `ParamSpec`, or `TypeVarTuple` declaration
 ]
 
 [lint.pyupgrade]

src/faceit/api/pagination.py

@@ -457,7 +457,7 @@ def _extract_unix_timestamp(
         if isinstance(page, dict):
             items = page.get(RAW_RESPONSE_ITEMS_KEY) or []
             return deep_get(items[-1], key) if items else None
-        assert isinstance(page, ItemPage)
+        assert isinstance(page, ItemPage)  # Type narrowing for mypy on Python < 3.9
         return getattr(page.get_last(), attr, None)
 
     @staticmethod

src/faceit/models/players/general.py

@@ -62,10 +62,9 @@ def _prepare_skill_level(cls, data: typing.Any) -> typing.Any:
             return data
 
         resolved = SkillLevel.get_level(game_id, skill_lvl)
-        assert resolved is not None, (
-            "`resolved` cannot be None because `game_id` was already validated "
-            "to be present in `ELO_THRESHOLDS`"
-        )
+        # `resolved` cannot be None because `game_id` was already validated
+        # to be present in `ELO_THRESHOLDS`
+        assert resolved is not None
         data[cls._SKILL_LVL] = resolved
         return data
 

tests/conftest.py

@@ -1,8 +1,36 @@
+import typing
+from unittest.mock import AsyncMock, Mock
 from uuid import uuid4
 
 import pytest
 
+from faceit.api.data.players import AsyncPlayers, SyncPlayers
+
 
 @pytest.fixture
 def valid_uuid() -> str:
     return str(uuid4())
+
+
+@pytest.fixture
+def mock_sync_client() -> Mock:
+    client = Mock()
+    client.get.return_value = {"player_id": "p1"}
+    return client
+
+
+@pytest.fixture
+def mock_async_client() -> Mock:
+    client = Mock()
+    client.get = AsyncMock(return_value={"player_id": "p1"})
+    return client
+
+
+@pytest.fixture
+def sync_players_raw(mock_sync_client: Mock) -> SyncPlayers[typing.Any]:
+    return SyncPlayers(client=mock_sync_client, raw=True)
+
+
+@pytest.fixture
+def async_players_raw(mock_async_client: Mock) -> AsyncPlayers[typing.Any]:
+    return AsyncPlayers(client=mock_async_client, raw=True)

tests/test_custom_types.py

@@ -1,13 +1,5 @@
-"""NOTE TO DEVELOPERS:
-
-These tests were generated with the assistance of AI and may require
-additional review or adjustments. Please verify that all test cases
-properly cover the expected behavior of the custom types, especially
-regarding edge cases and integration with `Pydantic`.
-"""
-
 import pytest
-from pydantic import AnyHttpUrl, BaseModel, ValidationError, TypeAdapter
+from pydantic import AnyHttpUrl, BaseModel, TypeAdapter, ValidationError
 
 from faceit.models.custom_types import (
     FaceitID,
@@ -26,7 +18,7 @@ def lang_adapter() -> TypeAdapter[LangFormattedAnyHttpUrl]:
 
 
 @pytest.mark.parametrize(
-    "input_value,expected",
+    ("input_value", "expected"),
     [
         (f"https://example.com/{langph}/docs", "https://example.com/docs"),
         (f"http://{langph}/foo/bar", "http://foo/bar"),
@@ -39,7 +31,9 @@ def lang_adapter() -> TypeAdapter[LangFormattedAnyHttpUrl]:
         ("", ""),
     ],
 )
-def test_validate_success(input_value, expected, lang_adapter):
+def test_validate_success(
+    input_value: str, expected: str, lang_adapter: TypeAdapter[LangFormattedAnyHttpUrl]
+) -> None:
     if expected == "" or expected.startswith("http"):
         assert (
             input_value == expected
@@ -52,33 +46,24 @@ def test_validate_success(input_value, expected, lang_adapter):
 
 
 class TestFaceitID:
-    def test_valid_uuid(self, valid_uuid):
-        # Test with a valid UUID string
-        valid_uuid = valid_uuid
+    def test_valid_uuid(self, valid_uuid: str) -> None:
         faceit_id = FaceitID._validate(valid_uuid)
         assert isinstance(faceit_id, FaceitID)
         assert str(faceit_id) == valid_uuid
 
-    def test_invalid_uuid(self):
-        # Test with an invalid UUID string
+    def test_invalid_uuid(self) -> None:
         with pytest.raises(ValueError, match="Invalid FaceitID:"):
             FaceitID._validate("not-a-uuid")
 
-        # Test with a non-string, non-UUID value
         with pytest.raises(AttributeError):
             FaceitID(123)
 
-    def test_suffix_handling(self, valid_uuid):
-        # Test that the 'gui' suffix is NOT automatically handled
-        # We need to manually remove it before validation
-        valid_uuid = valid_uuid
+    def test_suffix_handling(self, valid_uuid: str) -> None:
         suffixed_uuid = f"{valid_uuid}gui"
 
-        # This should fail because the suffix makes it an invalid UUID
         with pytest.raises(ValueError, match="is not a valid UUID format"):
             FaceitID._validate(suffixed_uuid)
 
-        # Manual handling of suffix
         if suffixed_uuid.endswith("gui"):
             cleaned_uuid = suffixed_uuid[:-3]
             faceit_id_from_cleaned = FaceitID._validate(cleaned_uuid)
@@ -87,41 +72,29 @@ def test_suffix_handling(self, valid_uuid):
 
 
 class TestFaceitTeamID:
-    def test_valid_team_id(self, valid_uuid):
-        # Test with a valid team ID (prefix + UUID)
-        valid_uuid = valid_uuid
+    def test_valid_team_id(self, valid_uuid: str) -> None:
         valid_team_id = f"team-{valid_uuid}"
 
         team_id = FaceitTeamID._validate(valid_team_id)
         assert isinstance(team_id, FaceitTeamID)
         assert str(team_id) == valid_team_id
 
-    def test_missing_prefix(self, valid_uuid):
-        # Test with a UUID without the required prefix
-        valid_uuid = valid_uuid
-
+    def test_missing_prefix(self, valid_uuid: str) -> None:
         with pytest.raises(ValueError, match="must start with 'team-'"):
             FaceitTeamID._validate(valid_uuid)
 
-    def test_invalid_uuid_part(self):
-        # Test with an invalid UUID part
+    def test_invalid_uuid_part(self) -> None:
         with pytest.raises(ValueError, match="contains invalid UUID part"):
             FaceitTeamID._validate("team-not-a-valid-uuid")
 
-    def test_suffix_handling(self, valid_uuid):
-        # Test that the 'gui' suffix is NOT automatically handled
-        valid_uuid = valid_uuid
+    def test_suffix_handling(self, valid_uuid: str) -> None:
         valid_team_id = f"team-{valid_uuid}"
         suffixed_team_id = f"{valid_team_id}gui"
+        _ = FaceitTeamID._validate(valid_team_id)
 
-        # This should work
-        team_id = FaceitTeamID._validate(valid_team_id)
-
-        # This should fail because the suffix makes the UUID part invalid
         with pytest.raises(ValueError, match="contains invalid UUID part"):
             FaceitTeamID._validate(suffixed_team_id)
 
-        # Manual handling of suffix
         if suffixed_team_id.endswith("gui"):
             cleaned_team_id = suffixed_team_id[:-3]
             team_id_from_cleaned = FaceitTeamID._validate(cleaned_team_id)
@@ -130,119 +103,89 @@ def test_suffix_handling(self, valid_uuid):
 
 
 class TestFaceitMatchID:
-    def test_valid_match_id(self, valid_uuid):
-        # Test with a valid match ID (prefix + UUID)
-        valid_uuid = valid_uuid
+    def test_valid_match_id(self, valid_uuid: str) -> None:
         valid_match_id = f"1-{valid_uuid}"
 
         match_id = FaceitMatchID._validate(valid_match_id)
         assert isinstance(match_id, FaceitMatchID)
         assert str(match_id) == valid_match_id
 
-    def test_missing_prefix(self, valid_uuid):
-        # Test with a UUID without the required prefix
-        valid_uuid = valid_uuid
-
+    def test_missing_prefix(self, valid_uuid: str) -> None:
         with pytest.raises(ValueError, match="must start with '1-'"):
             FaceitMatchID._validate(valid_uuid)
 
-    def test_invalid_uuid_part(self):
-        # Test with an invalid UUID part
+    def test_invalid_uuid_part(self) -> None:
         with pytest.raises(ValueError, match="contains invalid UUID part"):
             FaceitMatchID._validate("1-not-a-valid-uuid")
 
-    def test_suffix_handling(self, valid_uuid):
-        # Test that the 'gui' suffix is NOT automatically handled
-        valid_uuid = valid_uuid
+    def test_suffix_handling(self, valid_uuid: str) -> None:
         valid_match_id = f"1-{valid_uuid}"
         suffixed_match_id = f"{valid_match_id}gui"
+        _ = FaceitMatchID._validate(valid_match_id)
 
-        # This should work
-        match_id = FaceitMatchID._validate(valid_match_id)
-
-        # This should fail because the suffix makes the UUID part invalid
         with pytest.raises(ValueError, match="contains invalid UUID part"):
             FaceitMatchID._validate(suffixed_match_id)
 
-        # Manual handling of suffix
         if suffixed_match_id.endswith("gui"):
             cleaned_match_id = suffixed_match_id[:-3]
             match_id_from_cleaned = FaceitMatchID._validate(cleaned_match_id)
             assert isinstance(match_id_from_cleaned, FaceitMatchID)
             assert str(match_id_from_cleaned) == valid_match_id
 
 
-# Test Pydantic integration
 class TestPydanticIntegration:
-    def test_faceit_id_in_model(self, valid_uuid):
+    def test_faceit_id_in_model(self, valid_uuid: str) -> None:
         class UserModel(BaseModel):
             id: FaceitID
 
-        # Valid UUID
-        valid_uuid = valid_uuid
         user = UserModel(id=valid_uuid)
         assert isinstance(user.id, FaceitID)
         assert str(user.id) == valid_uuid
 
-        # UUID with suffix - Pydantic automatically handles this
         suffixed_uuid = f"{valid_uuid}gui"
         user = UserModel(id=suffixed_uuid)
         assert isinstance(user.id, FaceitID)
-        # The suffix should be automatically removed
         assert str(user.id) == valid_uuid
 
-        # Invalid UUID
         with pytest.raises(ValidationError):
             UserModel(id="not-a-uuid")
 
-    def test_faceit_team_id_in_model(self, valid_uuid):
+    def test_faceit_team_id_in_model(self, valid_uuid: str) -> None:
         class TeamModel(BaseModel):
             id: FaceitTeamID
 
-        # Valid team ID
-        valid_uuid = valid_uuid
         valid_team_id = f"team-{valid_uuid}"
         team = TeamModel(id=valid_team_id)
         assert isinstance(team.id, FaceitTeamID)
         assert str(team.id) == valid_team_id
 
-        # Team ID with suffix - Pydantic automatically handles this
         suffixed_team_id = f"{valid_team_id}gui"
         team = TeamModel(id=suffixed_team_id)
         assert isinstance(team.id, FaceitTeamID)
-        # The suffix should be automatically removed
         assert str(team.id) == valid_team_id
 
-        # Missing prefix
         with pytest.raises(ValidationError):
             TeamModel(id=valid_uuid)
 
-        # Invalid UUID part
         with pytest.raises(ValidationError):
             TeamModel(id="team-not-a-valid-uuid")
 
-    def test_faceit_match_id_in_model(self, valid_uuid):
+    def test_faceit_match_id_in_model(self, valid_uuid: str) -> None:
         class MatchModel(BaseModel):
             id: FaceitMatchID
 
-        # Valid match ID
-        valid_uuid = valid_uuid
         valid_match_id = f"1-{valid_uuid}"
         match = MatchModel(id=valid_match_id)
         assert isinstance(match.id, FaceitMatchID)
         assert str(match.id) == valid_match_id
 
-        # Match ID with suffix - Pydantic automatically handles this
         suffixed_match_id = f"{valid_match_id}gui"
         match = MatchModel(id=suffixed_match_id)
         assert isinstance(match.id, FaceitMatchID)
-        # The suffix should be automatically removed
         assert str(match.id) == valid_match_id
 
-        # Missing prefix
         with pytest.raises(ValidationError):
             MatchModel(id=valid_uuid)
 
-        # Invalid UUID part
         with pytest.raises(ValidationError):
             MatchModel(id="1-not-a-valid-uuid")