feat: add some tests

p1p1daster · p1p1daster · commit 6ae626bbde45 · 2025-07-12T00:36:34.000+03:00
diff --git a/.github/workflows/python-app.yml b/.github/workflows/python-app.yml
@@ -58,4 +58,4 @@ jobs:
 
       - name: Run linters
         run: |
-          poetry run ./scripts/docs-lint
+          poetry run bash ./scripts/docs-lint
diff --git a/pybotx/async_buffer.py b/pybotx/async_buffer.py
@@ -1,4 +1,3 @@
-# pragma: no cover
 import abc
 import os
 from typing import Optional
@@ -33,7 +32,7 @@ async def read(
 
 
 async def get_file_size(async_buffer: AsyncBufferReadable) -> int:
-    await async_buffer.seek(0, os.SEEK_END)  # pragma: no cover
-    file_size = await async_buffer.tell()  # pragma: no cover
-    await async_buffer.seek(0)  # pragma: no cover
-    return file_size  # pragma: no cover
+    await async_buffer.seek(0, os.SEEK_END)
+    file_size = await async_buffer.tell()
+    await async_buffer.seek(0)
+    return file_size
diff --git a/pybotx/client/chats_api/chat_info.py b/pybotx/client/chats_api/chat_info.py
@@ -46,17 +46,17 @@ class BotXAPIChatInfoResult(VerifiedPayloadBaseModel):
     @field_validator("members", mode="before")
     @classmethod
     def validate_members(
-        cls, value: List[Union[BotXAPIChatInfoMember, Dict[str, Any]]]
+        cls, value: List[Union[BotXAPIChatInfoMember, Dict[str, Any]]], info: Any
     ) -> List[Union[BotXAPIChatInfoMember, Dict[str, Any]]]:
         parsed: List[Union[BotXAPIChatInfoMember, Dict[str, Any]]] = []
         for item in value:
             if isinstance(item, dict):
                 try:
                     parsed.append(BotXAPIChatInfoMember.model_validate(item))
-                except ValidationError:  # pragma: no cover
+                except ValidationError:
                     parsed.append(item)
             else:
-                parsed.append(item)  # pragma: no cover
+                parsed.append(item)
         return parsed
 
 
@@ -66,9 +66,7 @@ class BotXAPIChatInfoResponsePayload(VerifiedPayloadBaseModel):
 
     def to_domain(self) -> ChatInfo:
         if any(isinstance(member, dict) for member in self.result.members):
-            logger.warning(
-                "One or more unsupported user types skipped"
-            )  # pragma: no cover
+            logger.warning("One or more unsupported user types skipped")
 
         members = [
             ChatInfoMember(
diff --git a/pybotx/client/chats_api/list_chats.py b/pybotx/client/chats_api/list_chats.py
@@ -28,17 +28,17 @@ class BotXAPIListChatResponsePayload(VerifiedPayloadBaseModel):
     @field_validator("result", mode="before")
     @classmethod
     def validate_result(
-        cls, value: List[Union[BotXAPIListChatResult, Dict[str, Any]]]
+        cls, value: List[Union[BotXAPIListChatResult, Dict[str, Any]]], info: Any
     ) -> List[Union[BotXAPIListChatResult, Dict[str, Any]]]:
         parsed: List[Union[BotXAPIListChatResult, Dict[str, Any]]] = []
         for item in value:
             if isinstance(item, dict):
                 try:
                     parsed.append(BotXAPIListChatResult.model_validate(item))
-                except ValidationError:  # pragma: no cover
+                except ValidationError:
                     parsed.append(item)
             else:
-                parsed.append(item)  # pragma: no cover
+                parsed.append(item)
         return parsed
 
     def to_domain(self) -> List[ChatListItem]:
@@ -58,9 +58,7 @@ def to_domain(self) -> List[ChatListItem]:
         ]
 
         if len(chats_list) != len(self.result):
-            logger.warning(
-                "One or more unsupported chat types skipped"
-            )  # pragma: no cover
+            logger.warning("One or more unsupported chat types skipped")
 
         return chats_list
 
diff --git a/pybotx/client/exceptions/callbacks.py b/pybotx/client/exceptions/callbacks.py
@@ -16,7 +16,7 @@ def __init__(self, callback: BotAPIMethodFailedCallback) -> None:
 
     def __reduce__(self) -> Any:
         # This method required to pass exception from pybotx logger to bot logger.
-        return type(self), (self.callback,)  # pragma: no cover
+        return type(self), (self.callback,)
 
 
 class CallbackNotReceivedError(Exception):
diff --git a/pybotx/client/exceptions/http.py b/pybotx/client/exceptions/http.py
@@ -16,7 +16,7 @@ def __init__(self, response: httpx.Response) -> None:
 
     def __reduce__(self) -> Any:
         # This method required to pass exception from pybotx logger to bot logger.
-        return type(self), (self.response,)  # pragma: no cover
+        return type(self), (self.response,)
 
 
 class InvalidBotXStatusCodeError(InvalidBotXResponseError):
diff --git a/pybotx/client/files_api/download_file.py b/pybotx/client/files_api/download_file.py
@@ -61,7 +61,7 @@ async def execute(
             params=payload.jsonable_dict(),
         ) as response:
             # https://github.com/nedbat/coveragepy/issues/1223
-            async for chunk in response.aiter_bytes():  # pragma: no cover
+            async for chunk in response.aiter_bytes():  # pragma: no branch
                 await async_buffer.write(chunk)
 
         await async_buffer.seek(0)
diff --git a/pybotx/client/users_api/users_as_csv.py b/pybotx/client/users_api/users_as_csv.py
@@ -43,5 +43,5 @@ async def execute(
             params=payload.jsonable_dict(),
         ) as response:
             # https://github.com/nedbat/coveragepy/issues/1223
-            async for chunk in response.aiter_bytes():  # pragma: no cover
+            async for chunk in response.aiter_bytes():  # pragma: no branch
                 await async_buffer.write(chunk)
diff --git a/pybotx/models/bot_account.py b/pybotx/models/bot_account.py
@@ -20,10 +20,10 @@ class BotAccountWithSecret(BaseModel):
 
     model_config = ConfigDict(frozen=True)
 
-    def __setattr__(self, name: str, value: object) -> None:  # pragma: no cover
+    def __setattr__(self, name: str, value: object) -> None:
         if not getattr(self.model_config, "frozen", True) and name in self.model_fields:
             raise TypeError("BotAccountWithSecret is immutable")  # pragma: no cover
-        super().__setattr__(name, value)  # pragma: no cover
+        super().__setattr__(name, value)
 
     @property
     def host(self) -> str:
diff --git a/pybotx/models/message/incoming_message.py b/pybotx/models/message/incoming_message.py
@@ -200,7 +200,7 @@ class BotAPIIncomingMessage(BotAPIBaseCommand):
     @classmethod
     def validate_items(
         cls, value: List[Union[Dict[str, Any], Any]], info: Any
-    ) -> List[Any]:  # pragma: no cover
+    ) -> List[Any]:
         item_model = (
             BotAPIAttachment if info.field_name == "attachments" else BotAPIEntity
         )
@@ -211,16 +211,14 @@ def validate_items(
                     parsed.append(TypeAdapter(item_model).validate_python(item))
                 except ValidationError:
                     parsed.append(item)
-                else:
-                    parsed.append(item)  # pragma: no cover
         return parsed
 
     def to_domain(self, raw_command: Dict[str, Any]) -> IncomingMessage:  # noqa: WPS231
         if self.sender.device_meta:
             pushes = self.sender.device_meta.pushes
             timezone = self.sender.device_meta.timezone
             permissions = self.sender.device_meta.permissions
-        else:  # pragma: no cover
+        else:
             pushes, timezone, permissions = None, None, None
 
         device = UserDevice(
diff --git a/pybotx/models/message/markup.py b/pybotx/models/message/markup.py
@@ -185,13 +185,11 @@ class BotXAPIButton(UnverifiedPayloadBaseModel):
 
 class BotXAPIMarkup(RootModel[List[List[BotXAPIButton]]]):
     def json(self) -> str:  # type: ignore [override]
-        clean_dict = _remove_undefined(self.model_dump())  # pragma: no cover
-        return json.dumps(
-            clean_dict, default=to_jsonable_python, ensure_ascii=False
-        )  # pragma: no cover
+        clean_dict = _remove_undefined(self.model_dump())
+        return json.dumps(clean_dict, default=to_jsonable_python, ensure_ascii=False)
 
-    def jsonable_dict(self) -> Dict[str, Any]:
-        return cast(Dict[str, Any], json.loads(self.json()))  # pragma: no cover
+    def jsonable_dict(self) -> List[List[Dict[str, Any]]]:
+        return cast(List[List[Dict[str, Any]]], json.loads(self.json()))
 
 
 def api_button_from_domain(button: Button) -> BotXAPIButton:
diff --git a/tests/client/chats_api/test_chat_info_validation.py b/tests/client/chats_api/test_chat_info_validation.py
@@ -0,0 +1,33 @@
+
+from uuid import UUID
+
+from pybotx.client.chats_api.chat_info import (
+    BotXAPIChatInfoResult,
+    BotXAPIChatInfoMember,
+)
+from pybotx.models.enums import APIUserKinds
+
+
+class MockValidationInfo:
+    """Mock class for ValidationInfo protocol."""
+
+    def __init__(self, field_name: str) -> None:
+        self.field_name = field_name
+
+
+def test_validate_members_non_dict() -> None:
+    # - Arrange -
+    # Create a non-dict member
+    non_dict_member = BotXAPIChatInfoMember(
+        admin=True,
+        user_huid=UUID("054af49e-5e18-4dca-ad73-4f96b6de63fa"),
+        user_kind=APIUserKinds.BOTX,
+    )
+
+    # - Act -
+    # Call validate_members with a list containing a non-dict item
+    result = BotXAPIChatInfoResult.validate_members([non_dict_member], MockValidationInfo(field_name="members"))  # type: ignore[call-arg, arg-type]
+
+    # - Assert -
+    # Verify that the non-dict item is included in the result
+    assert non_dict_member in result
diff --git a/tests/client/chats_api/test_list_chats_validation.py b/tests/client/chats_api/test_list_chats_validation.py
@@ -0,0 +1,38 @@
+from datetime import datetime
+from uuid import UUID
+
+from pybotx.client.chats_api.list_chats import (
+    BotXAPIListChatResponsePayload,
+    BotXAPIListChatResult,
+)
+from pybotx.models.enums import APIChatTypes
+
+
+class MockValidationInfo:
+    """Mock class for ValidationInfo protocol."""
+
+    def __init__(self, field_name: str) -> None:
+        self.field_name = field_name
+
+
+def test_validate_result_non_dict() -> None:
+    # - Arrange -
+    # Create a non-dict result
+    non_dict_result = BotXAPIListChatResult(
+        group_chat_id=UUID("054af49e-5e18-4dca-ad73-4f96b6de63fa"),
+        chat_type=APIChatTypes.GROUP_CHAT,
+        name="Test Chat",
+        description="Test Description",
+        members=[UUID("154af49e-5e18-4dca-ad73-4f96b6de63fa")],
+        inserted_at=datetime.now(),
+        updated_at=datetime.now(),
+        shared_history=True,
+    )
+
+    # - Act -
+    # Call validate_result with a list containing a non-dict item
+    result = BotXAPIListChatResponsePayload.validate_result([non_dict_result], MockValidationInfo(field_name="result"))  # type: ignore[call-arg, arg-type]
+
+    # - Assert -
+    # Verify that the non-dict item is included in the result
+    assert non_dict_result in result
diff --git a/tests/client/exceptions/test_callbacks.py b/tests/client/exceptions/test_callbacks.py
@@ -0,0 +1,26 @@
+import pickle
+from uuid import UUID
+
+from pybotx.client.exceptions.callbacks import BotXMethodFailedCallbackReceivedError
+from pybotx.models.method_callbacks import BotAPIMethodFailedCallback
+
+
+def test_botx_method_failed_callback_received_error_reduce() -> None:
+    # - Arrange -
+    callback = BotAPIMethodFailedCallback(
+        sync_id=UUID("054af49e-5e18-4dca-ad73-4f96b6de63fa"),
+        status="error",
+        reason="test_reason",
+        errors=["test_error"],
+        error_data={},
+    )
+    error = BotXMethodFailedCallbackReceivedError(callback)
+
+    # - Act -
+    # Pickle and unpickle the error
+    pickled_error = pickle.dumps(error)
+    unpickled_error = pickle.loads(pickled_error)
+
+    # - Assert -
+    # Verify that the unpickled error has the same callback
+    assert unpickled_error.callback == error.callback
diff --git a/tests/client/exceptions/test_http.py b/tests/client/exceptions/test_http.py
@@ -0,0 +1,25 @@
+import pickle
+import httpx
+
+from pybotx.client.exceptions.http import InvalidBotXResponseError
+
+
+def test_invalid_botx_response_error_reduce() -> None:
+    # - Arrange -
+    request = httpx.Request("GET", "https://example.com")
+    response = httpx.Response(
+        status_code=400,
+        json={"status": "error", "reason": "test_reason", "errors": ["test_error"]},
+        request=request,
+    )
+    error = InvalidBotXResponseError(response)
+
+    # - Act -
+    # Pickle and unpickle the error
+    pickled_error = pickle.dumps(error)
+    unpickled_error = pickle.loads(pickled_error)
+
+    # - Assert -
+    # Verify that the unpickled error has the same response
+    assert unpickled_error.response.status_code == error.response.status_code
+    assert unpickled_error.response.json() == error.response.json()
diff --git a/tests/models/test_bot_account_with_secret.py b/tests/models/test_bot_account_with_secret.py
@@ -0,0 +1,42 @@
+import pytest
+from pydantic import ValidationError
+from unittest.mock import patch
+from uuid import UUID
+
+from pybotx.models.bot_account import BotAccountWithSecret
+
+
+def test_bot_account_with_secret_immutable() -> None:
+    # - Arrange -
+    bot_account = BotAccountWithSecret(
+        id=UUID("054af49e-5e18-4dca-ad73-4f96b6de63fa"),
+        cts_url="https://example.com",
+        secret_key="secret",
+    )
+
+    # - Act & Assert -
+    with pytest.raises(ValidationError) as exc:
+        bot_account.id = UUID("154af49e-5e18-4dca-ad73-4f96b6de63fa")  # type: ignore[misc]
+
+    assert "frozen_instance" in str(exc.value)
+
+
+def test_bot_account_with_secret_not_frozen() -> None:
+    # - Arrange -
+    bot_account = BotAccountWithSecret(
+        id=UUID("054af49e-5e18-4dca-ad73-4f96b6de63fa"),
+        cts_url="https://example.com",
+        secret_key="secret",
+    )
+
+    # Mock the condition to force the TypeError
+    with patch.object(
+        BotAccountWithSecret,
+        "__setattr__",
+        side_effect=TypeError("BotAccountWithSecret is immutable"),
+    ):
+        # - Act & Assert -
+        with pytest.raises(TypeError) as exc:
+            bot_account.id = UUID("154af49e-5e18-4dca-ad73-4f96b6de63fa")  # type: ignore[misc]
+
+        assert "BotAccountWithSecret is immutable" in str(exc.value)
diff --git a/tests/models/test_botx_api_markup.py b/tests/models/test_botx_api_markup.py
diff --git a/tests/models/test_incoming_message_validation.py b/tests/models/test_incoming_message_validation.py
diff --git a/tests/test_async_buffer.py b/tests/test_async_buffer.py
