Adjust tests

telegram/_bot.py

@@ -133,10 +133,10 @@ class Bot(TelegramObject, AbstractAsyncContextManager):
     .. code:: python
 
         try:
-            bot.initialize()
+            await bot.initialize()
             # code
         finally:
-            request_object.shutdown()
+            await request_object.shutdown()
 
     Note:
         Most bot methods have the argument ``api_kwargs`` which allows to pass arbitrary keywords
@@ -4153,7 +4153,7 @@ async def revoke_chat_invite_link(
         return ChatInviteLink.de_json(result, self)  # type: ignore[return-value, arg-type]
 
     @_log
-    def approve_chat_join_request(
+    async def approve_chat_join_request(
         self,
         chat_id: Union[str, int],
         user_id: int,
@@ -4185,12 +4185,14 @@ def approve_chat_join_request(
         """
         data: JSONDict = {'chat_id': chat_id, 'user_id': user_id}
 
-        result = self._post('approveChatJoinRequest', data, timeout=timeout, api_kwargs=api_kwargs)
+        result = await self._post(
+            'approveChatJoinRequest', data, timeout=timeout, api_kwargs=api_kwargs
+        )
 
         return result  # type: ignore[return-value]
 
     @_log
-    def decline_chat_join_request(
+    async def decline_chat_join_request(
         self,
         chat_id: Union[str, int],
         user_id: int,
@@ -4222,7 +4224,9 @@ def decline_chat_join_request(
         """
         data: JSONDict = {'chat_id': chat_id, 'user_id': user_id}
 
-        result = self._post('declineChatJoinRequest', data, timeout=timeout, api_kwargs=api_kwargs)
+        result = await self._post(
+            'declineChatJoinRequest', data, timeout=timeout, api_kwargs=api_kwargs
+        )
 
         return result  # type: ignore[return-value]
 

telegram/_chat.py

@@ -1451,7 +1451,7 @@ async def copy_message(
             api_kwargs=api_kwargs,
         )
 
-    def export_invite_link(
+    async def export_invite_link(
         self,
         timeout: ODVInput[float] = DEFAULT_NONE,
         api_kwargs: JSONDict = None,
@@ -1469,11 +1469,11 @@ def export_invite_link(
             :obj:`str`: New invite link on success.
 
         """
-        return self.get_bot().export_chat_invite_link(
+        return await self.get_bot().export_chat_invite_link(
             chat_id=self.id, timeout=timeout, api_kwargs=api_kwargs
         )
 
-    def create_invite_link(
+    async def create_invite_link(
         self,
         expire_date: Union[int, datetime] = None,
         member_limit: int = None,
@@ -1499,7 +1499,7 @@ def create_invite_link(
             :class:`telegram.ChatInviteLink`
 
         """
-        return self.get_bot().create_chat_invite_link(
+        return await self.get_bot().create_chat_invite_link(
             chat_id=self.id,
             expire_date=expire_date,
             member_limit=member_limit,
@@ -1509,7 +1509,7 @@ def create_invite_link(
             creates_join_request=creates_join_request,
         )
 
-    def edit_invite_link(
+    async def edit_invite_link(
         self,
         invite_link: str,
         expire_date: Union[int, datetime] = None,
@@ -1535,7 +1535,7 @@ def edit_invite_link(
             :class:`telegram.ChatInviteLink`
 
         """
-        return self.get_bot().edit_chat_invite_link(
+        return await self.get_bot().edit_chat_invite_link(
             chat_id=self.id,
             invite_link=invite_link,
             expire_date=expire_date,
@@ -1546,7 +1546,7 @@ def edit_invite_link(
             creates_join_request=creates_join_request,
         )
 
-    def revoke_invite_link(
+    async def revoke_invite_link(
         self,
         invite_link: str,
         timeout: ODVInput[float] = DEFAULT_NONE,
@@ -1565,11 +1565,11 @@ def revoke_invite_link(
             :class:`telegram.ChatInviteLink`
 
         """
-        return self.get_bot().revoke_chat_invite_link(
+        return await self.get_bot().revoke_chat_invite_link(
             chat_id=self.id, invite_link=invite_link, timeout=timeout, api_kwargs=api_kwargs
         )
 
-    def approve_join_request(
+    async def approve_join_request(
         self,
         user_id: int,
         timeout: ODVInput[float] = DEFAULT_NONE,
@@ -1588,11 +1588,11 @@ def approve_join_request(
             :obj:`bool`: On success, :obj:`True` is returned.
 
         """
-        return self.get_bot().approve_chat_join_request(
+        return await self.get_bot().approve_chat_join_request(
             chat_id=self.id, user_id=user_id, timeout=timeout, api_kwargs=api_kwargs
         )
 
-    def decline_join_request(
+    async def decline_join_request(
         self,
         user_id: int,
         timeout: ODVInput[float] = DEFAULT_NONE,
@@ -1611,6 +1611,6 @@ def decline_join_request(
             :obj:`bool`: On success, :obj:`True` is returned.
 
         """
-        return self.get_bot().decline_chat_join_request(
+        return await self.get_bot().decline_chat_join_request(
             chat_id=self.id, user_id=user_id, timeout=timeout, api_kwargs=api_kwargs
         )

telegram/_chatjoinrequest.py

@@ -109,7 +109,7 @@ def to_dict(self) -> JSONDict:
 
         return data
 
-    def approve(
+    async def approve(
         self,
         timeout: ODVInput[float] = DEFAULT_NONE,
         api_kwargs: JSONDict = None,
@@ -126,11 +126,11 @@ def approve(
             :obj:`bool`: On success, :obj:`True` is returned.
 
         """
-        return self.get_bot().approve_chat_join_request(
+        return await self.get_bot().approve_chat_join_request(
             chat_id=self.chat.id, user_id=self.from_user.id, timeout=timeout, api_kwargs=api_kwargs
         )
 
-    def decline(
+    async def decline(
         self,
         timeout: ODVInput[float] = DEFAULT_NONE,
         api_kwargs: JSONDict = None,
@@ -147,6 +147,6 @@ def decline(
             :obj:`bool`: On success, :obj:`True` is returned.
 
         """
-        return self.get_bot().decline_chat_join_request(
+        return await self.get_bot().decline_chat_join_request(
             chat_id=self.chat.id, user_id=self.from_user.id, timeout=timeout, api_kwargs=api_kwargs
         )

telegram/_user.py

@@ -1139,7 +1139,7 @@ async def copy_message(
             api_kwargs=api_kwargs,
         )
 
-    def approve_join_request(
+    async def approve_join_request(
         self,
         chat_id: Union[int, str],
         timeout: ODVInput[float] = DEFAULT_NONE,
@@ -1158,11 +1158,11 @@ def approve_join_request(
             :obj:`bool`: On success, :obj:`True` is returned.
 
         """
-        return self.get_bot().approve_chat_join_request(
+        return await self.get_bot().approve_chat_join_request(
             user_id=self.id, chat_id=chat_id, timeout=timeout, api_kwargs=api_kwargs
         )
 
-    def decline_join_request(
+    async def decline_join_request(
         self,
         chat_id: Union[int, str],
         timeout: ODVInput[float] = DEFAULT_NONE,
@@ -1181,6 +1181,6 @@ def decline_join_request(
             :obj:`bool`: On success, :obj:`True` is returned.
 
         """
-        return self.get_bot().decline_chat_join_request(
+        return await self.get_bot().decline_chat_join_request(
             user_id=self.id, chat_id=chat_id, timeout=timeout, api_kwargs=api_kwargs
         )

telegram/ext/_dispatcher.py

@@ -452,7 +452,7 @@ def stop(self) -> None:
             self.persistence.flush()
 
         # Shut down the bot
-        self.bot.shutdown()
+        # self.bot.shutdown()
 
     @property
     def has_running_threads(self) -> bool:  # skipcq: PY-D0003

telegram/request/_baserequest.py

@@ -67,10 +67,10 @@ class BaseRequest(
     .. code:: python
 
         try:
-            request_object.initialize()
+            await request_object.initialize()
             # code
         finally:
-            request_object.stop()
+            await request_object.stop()
     """
 
     __slots__ = ()

tests/test_bot.py

@@ -1945,33 +1945,37 @@ async def test_export_chat_invite_link(self, bot, channel_id):
         assert isinstance(invite_link, str)
         assert invite_link != ''
 
-    def test_create_edit_invite_link_mutually_exclusive_arguments(self, bot, channel_id):
+    @pytest.mark.asyncio
+    async def test_create_edit_invite_link_mutually_exclusive_arguments(self, bot, channel_id):
         data = {'chat_id': channel_id, 'member_limit': 17, 'creates_join_request': True}
 
         with pytest.raises(ValueError, match="`member_limit` can't be specified"):
-            bot.create_chat_invite_link(**data)
+            await bot.create_chat_invite_link(**data)
 
         data.update({'invite_link': 'https://invite.link'})
         with pytest.raises(ValueError, match="`member_limit` can't be specified"):
-            bot.edit_chat_invite_link(**data)
+            await bot.edit_chat_invite_link(**data)
 
     @flaky(3, 1)
     @pytest.mark.parametrize('creates_join_request', [True, False])
     @pytest.mark.parametrize('name', [None, 'name'])
-    def test_create_chat_invite_link_basics(self, bot, creates_join_request, name, channel_id):
+    @pytest.mark.asyncio
+    async def test_create_chat_invite_link_basics(
+        self, bot, creates_join_request, name, channel_id
+    ):
         data = {}
         if creates_join_request:
             data['creates_join_request'] = True
         if name:
             data['name'] = name
-        invite_link = bot.create_chat_invite_link(chat_id=channel_id, **data)
+        invite_link = await bot.create_chat_invite_link(chat_id=channel_id, **data)
 
         assert invite_link.member_limit is None
         assert invite_link.expire_date is None
         assert invite_link.creates_join_request == creates_join_request
         assert invite_link.name == name
 
-        revoked_link = bot.revoke_chat_invite_link(
+        revoked_link = await bot.revoke_chat_invite_link(
             chat_id=channel_id, invite_link=invite_link.invite_link
         )
         assert revoked_link.is_revoked
@@ -2012,7 +2016,7 @@ async def test_advanced_chat_invite_links(self, bot, channel_id, datetime):
         assert edited_invite_link.name == 'NewName'
         assert edited_invite_link.member_limit == 20
 
-        edited_invite_link = bot.edit_chat_invite_link(
+        edited_invite_link = await bot.edit_chat_invite_link(
             channel_id,
             invite_link.invite_link,
             name='EvenNewerName',
@@ -2062,7 +2066,7 @@ async def test_advanced_chat_invite_links_default_tzinfo(self, tz_bot, channel_i
         assert edited_invite_link.name == 'NewName'
         assert edited_invite_link.member_limit == 20
 
-        edited_invite_link = tz_bot.edit_chat_invite_link(
+        edited_invite_link = await tz_bot.edit_chat_invite_link(
             channel_id,
             invite_link.invite_link,
             name='EvenNewerName',
@@ -2081,20 +2085,22 @@ async def test_advanced_chat_invite_links_default_tzinfo(self, tz_bot, channel_i
         assert revoked_invite_link.is_revoked is True
 
     @flaky(3, 1)
-    def test_approve_chat_join_request(self, bot, chat_id, channel_id):
+    @pytest.mark.asyncio
+    async def test_approve_chat_join_request(self, bot, chat_id, channel_id):
         # TODO: Need incoming join request to properly test
         # Since we can't create join requests on the fly, we just tests the call to TG
         # by checking that it complains about approving a user who is already in the chat
         with pytest.raises(BadRequest, match='User_already_participant'):
-            bot.approve_chat_join_request(chat_id=channel_id, user_id=chat_id)
+            await bot.approve_chat_join_request(chat_id=channel_id, user_id=chat_id)
 
     @flaky(3, 1)
-    def test_decline_chat_join_request(self, bot, chat_id, channel_id):
+    @pytest.mark.asyncio
+    async def test_decline_chat_join_request(self, bot, chat_id, channel_id):
         # TODO: Need incoming join request to properly test
         # Since we can't create join requests on the fly, we just tests the call to TG
         # by checking that it complains about declining a user who is already in the chat
         with pytest.raises(BadRequest, match='User_already_participant'):
-            bot.decline_chat_join_request(chat_id=channel_id, user_id=chat_id)
+            await bot.decline_chat_join_request(chat_id=channel_id, user_id=chat_id)
 
     @flaky(3, 1)
     @pytest.mark.asyncio

tests/test_chat.py

@@ -659,35 +659,37 @@ async def make_assertion(*_, **kwargs):
         monkeypatch.setattr(chat.get_bot(), 'revoke_chat_invite_link', make_assertion)
         assert await chat.revoke_invite_link(invite_link=link)
 
-    def test_approve_join_request(self, monkeypatch, chat):
-        def make_assertion(*_, **kwargs):
+    @pytest.mark.asyncio
+    async def test_approve_join_request(self, monkeypatch, chat):
+        async def make_assertion(*_, **kwargs):
             return kwargs['chat_id'] == chat.id and kwargs['user_id'] == 42
 
         assert check_shortcut_signature(
             Chat.approve_join_request, Bot.approve_chat_join_request, ['chat_id'], []
         )
-        assert check_shortcut_call(
+        assert await check_shortcut_call(
             chat.approve_join_request, chat.get_bot(), 'approve_chat_join_request'
         )
-        assert check_defaults_handling(chat.approve_join_request, chat.get_bot())
+        assert await check_defaults_handling(chat.approve_join_request, chat.get_bot())
 
         monkeypatch.setattr(chat.get_bot(), 'approve_chat_join_request', make_assertion)
-        assert chat.approve_join_request(user_id=42)
+        assert await chat.approve_join_request(user_id=42)
 
-    def test_decline_join_request(self, monkeypatch, chat):
-        def make_assertion(*_, **kwargs):
+    @pytest.mark.asyncio
+    async def test_decline_join_request(self, monkeypatch, chat):
+        async def make_assertion(*_, **kwargs):
             return kwargs['chat_id'] == chat.id and kwargs['user_id'] == 42
 
         assert check_shortcut_signature(
             Chat.decline_join_request, Bot.decline_chat_join_request, ['chat_id'], []
         )
-        assert check_shortcut_call(
+        assert await check_shortcut_call(
             chat.decline_join_request, chat.get_bot(), 'decline_chat_join_request'
         )
-        assert check_defaults_handling(chat.decline_join_request, chat.get_bot())
+        assert await check_defaults_handling(chat.decline_join_request, chat.get_bot())
 
         monkeypatch.setattr(chat.get_bot(), 'decline_chat_join_request', make_assertion)
-        assert chat.decline_join_request(user_id=42)
+        assert await chat.decline_join_request(user_id=42)
 
     def test_equality(self):
         a = Chat(self.id_, self.title, self.type_)